diff --git a/lib/runtime/Cargo.lock b/lib/runtime/Cargo.lock index 39f1ce97b..d0d30caee 100644 --- a/lib/runtime/Cargo.lock +++ b/lib/runtime/Cargo.lock @@ -104,6 +104,14 @@ dependencies = [ "vec_map 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)", ] +[[package]] +name = "cmake" +version = "0.1.35" +source = "registry+https://github.com/rust-lang/crates.io-index" +dependencies = [ + "cc 1.0.28 (registry+https://github.com/rust-lang/crates.io-index)", +] + [[package]] name = "cranelift-bforest" version = "0.26.0" @@ -221,6 +229,11 @@ dependencies = [ "synstructure 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)", ] +[[package]] +name = "field-offset" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" + [[package]] name = "gcc" version = "0.3.55" @@ -478,6 +491,16 @@ name = "serde" version = "1.0.84" source = "registry+https://github.com/rust-lang/crates.io-index" +[[package]] +name = "serde_derive" +version = "1.0.84" +source = "registry+https://github.com/rust-lang/crates.io-index" +dependencies = [ + "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)", + "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)", + "syn 0.15.24 (registry+https://github.com/rust-lang/crates.io-index)", +] + [[package]] name = "serde_json" version = "1.0.34" @@ -585,6 +608,27 @@ name = "void" version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" +[[package]] +name = "wabt" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +dependencies = [ + "serde 1.0.84 (registry+https://github.com/rust-lang/crates.io-index)", + "serde_derive 1.0.84 (registry+https://github.com/rust-lang/crates.io-index)", + "serde_json 1.0.34 (registry+https://github.com/rust-lang/crates.io-index)", + "wabt-sys 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)", +] + +[[package]] +name = "wabt-sys" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +dependencies = [ + "cc 1.0.28 (registry+https://github.com/rust-lang/crates.io-index)", + "cmake 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)", + "glob 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)", +] + [[package]] name = "wasmer-clif-backend" version = "0.1.0" @@ -604,10 +648,12 @@ name = "wasmer-runtime" version = "0.1.0" dependencies = [ "errno 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)", + "field-offset 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)", "hashbrown 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)", "libffi 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)", "nix 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)", "page_size 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)", + "wabt 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)", "wasmer-clif-backend 0.1.0", ] @@ -672,6 +718,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" "checksum cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "082bb9b28e00d3c9d39cc03e64ce4cea0f1bb9b3fde493f0cbc008472d22bdf4" "checksum clang-sys 0.21.2 (registry+https://github.com/rust-lang/crates.io-index)" = "e414af9726e1d11660801e73ccc7fb81803fb5f49e5903a25b348b2b3b480d2e" "checksum clap 2.32.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b957d88f4b6a63b9d70d5f454ac8011819c6efa7727858f458ab71c756ce2d3e" +"checksum cmake 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)" = "6ec65ee4f9c9d16f335091d23693457ed4928657ba4982289d7fafee03bc614a" "checksum cranelift-bforest 0.26.0 (registry+https://github.com/rust-lang/crates.io-index)" = "40f8ff24e9a6c89b8a846b14df9a34d2cac17cea7bdb5c81ed6b4744ee0e38bf" "checksum cranelift-codegen 0.26.0 (registry+https://github.com/rust-lang/crates.io-index)" = "42f5b809bd885c368e01aeec8fe04f21dcb07569834b907d75b4a7bed8d067eb" "checksum cranelift-codegen-meta 0.26.0 (registry+https://github.com/rust-lang/crates.io-index)" = "014c23ed3ebdc8377d41540af638245207dd169f421df042dfccc867465734ed" @@ -684,6 +731,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" "checksum errno-dragonfly 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "14ca354e36190500e1e1fb267c647932382b54053c50b14970856c0b00a35067" "checksum failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "795bd83d3abeb9220f257e597aa0080a508b27533824adf336529648f6abf7e2" "checksum failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "ea1063915fd7ef4309e222a5a07cf9c319fb9c7836b1f89b85458672dbb127e1" +"checksum field-offset 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "64e9bc339e426139e02601fa69d101e96a92aee71b58bc01697ec2a63a5c9e68" "checksum gcc 0.3.55 (registry+https://github.com/rust-lang/crates.io-index)" = "8f5f3913fa0bfe7ee1fd8248b6b9f42a5af4b9d65ec2dd2c3c26132b950ecfc2" "checksum glob 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)" = "8be18de09a56b60ed0edf84bc9df007e30040691af7acd1c41874faac5895bfb" "checksum hashbrown 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "64b7d419d0622ae02fe5da6b9a5e1964b610a65bb37923b976aeebb6dbb8f86e" @@ -719,6 +767,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" "checksum semver 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403" "checksum semver-parser 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3" "checksum serde 1.0.84 (registry+https://github.com/rust-lang/crates.io-index)" = "0e732ed5a5592c17d961555e3b552985baf98d50ce418b7b655f31f6ba7eb1b7" +"checksum serde_derive 1.0.84 (registry+https://github.com/rust-lang/crates.io-index)" = "b4d6115a3ca25c224e409185325afc16a0d5aaaabc15c42b09587d6f1ba39a5b" "checksum serde_json 1.0.34 (registry+https://github.com/rust-lang/crates.io-index)" = "bdf540260cfee6da923831f4776ddc495ada940c30117977c70f1313a6130545" "checksum strsim 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bb4f380125926a99e52bc279241539c018323fab05ad6368b56f93d9369ff550" "checksum syn 0.15.24 (registry+https://github.com/rust-lang/crates.io-index)" = "734ecc29cd36e8123850d9bf21dfd62ef8300aaa8f879aabaa899721808be37c" @@ -734,6 +783,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" "checksum vec_map 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "05c78687fb1a80548ae3250346c3db86a80a7cdd77bda190189f2d0a0987c81a" "checksum version_check 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "914b1a6776c4c929a602fafd8bc742e06365d4bcbe48c30f9cca5824f70dc9dd" "checksum void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d" +"checksum wabt 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "0246aa1834c47c5f3dd87c0932a2c78edd1e9318ced5e92a41f30a0ab4e3a91f" +"checksum wabt-sys 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)" = "462336bb61096e64761730e0dea1bc8b777bd4e3689c7e813c81f1cfdf4e8a51" "checksum wasmparser 0.22.1 (registry+https://github.com/rust-lang/crates.io-index)" = "f46e666ecb4a406483a59a49f9d0c17f327e70da53a128eccddae2eadb95865c" "checksum wasmparser 0.23.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b5e01c420bc7d36e778bd242e1167b079562ba8b34087122cc9057187026d060" "checksum which 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)" = "e84a603e7e0b1ce1aa1ee2b109c7be00155ce52df5081590d1ffb93f4f515cb2" diff --git a/lib/runtime/Cargo.toml b/lib/runtime/Cargo.toml index 70c08f419..3281079f3 100644 --- a/lib/runtime/Cargo.toml +++ b/lib/runtime/Cargo.toml @@ -17,4 +17,5 @@ wabt = "0.7.2" [dev-dependencies] wasmer-clif-backend = { path = "../clif-backend" } -wabt = "0.7.2" \ No newline at end of file +wabt = "0.7.2" +field-offset = "0.1.1" \ No newline at end of file diff --git a/lib/runtime/build/spectests.rs b/lib/runtime/build/spectests.rs index 319958ec8..7ef42ed77 100644 --- a/lib/runtime/build/spectests.rs +++ b/lib/runtime/build/spectests.rs @@ -107,9 +107,9 @@ fn wabt2rust_value_bare(v: &Value) -> String { Value::F32(v) => { if v.is_infinite() { if v.is_sign_negative() { - "f32::NEG_INFINITY".to_string() + "f32::NEG_INFINITY.to_bits()".to_string() } else { - "f32::INFINITY".to_string() + "f32::INFINITY.to_bits()".to_string() } } else if v.is_nan() { // Support for non-canonical NaNs @@ -121,9 +121,9 @@ fn wabt2rust_value_bare(v: &Value) -> String { Value::F64(v) => { if v.is_infinite() { if v.is_sign_negative() { - "f64::NEG_INFINITY".to_string() + "f64::NEG_INFINITY.to_bits()".to_string() } else { - "f64::INFINITY".to_string() + "f64::INFINITY.to_bits()".to_string() } } else if v.is_nan() { format!("f64::from_bits({:?})", v.to_bits()) @@ -141,9 +141,9 @@ fn wabt2rust_value(v: &Value) -> String { Value::F32(v) => { if v.is_infinite() { if v.is_sign_negative() { - "Value::F32(f32::NEG_INFINITY)".to_string() + "Value::F32(f32::NEG_INFINITY.to_bits())".to_string() } else { - "Value::F32(f32::INFINITY)".to_string() + "Value::F32(f32::INFINITY.to_bits())".to_string() } } else if v.is_nan() { // Support for non-canonical NaNs @@ -155,9 +155,9 @@ fn wabt2rust_value(v: &Value) -> String { Value::F64(v) => { if v.is_infinite() { if v.is_sign_negative() { - "Value::F64(f64::NEG_INFINITY)".to_string() + "Value::F64(f64::NEG_INFINITY.to_bits())".to_string() } else { - "Value::F64(f64::INFINITY)".to_string() + "Value::F64(f64::INFINITY.to_bits())".to_string() } } else if v.is_nan() { format!("Value::F64(f64::from_bits({:?}) as u64)", v.to_bits()) @@ -204,12 +204,13 @@ impl WastTestGenerator { dead_code )] use wabt::wat2wasm; +use std::{{f32, f64}}; use wasmer_runtime::types::Value; use wasmer_runtime::{{Instance, Module}}; use wasmer_clif_backend::CraneliftCompiler; -use crate::_common::{{ +use crate::spectests::_common::{{ spectest_importobject, NaNCheck, }};\n\n", @@ -267,7 +268,7 @@ fn test_module_{}() {{ // self.module_calls.insert(self.last_module, vec![]); self.buffer.push_str( format!( - "fn create_module_{}() -> Instance {{ + "fn create_module_{}() -> Box {{ let module_str = \"{}\"; 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\"); @@ -310,7 +311,7 @@ fn test_module_{}() {{ "#[test] fn {}_assert_invalid() {{ let wasm_binary = {:?}; - let module = wasmer_runtime::compile(wasm_binary, &CraneliftCompiler::new()); + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(module.is_err(), \"WASM should not compile as is invalid\"); }}\n", command_name, @@ -333,7 +334,11 @@ fn {}_assert_invalid() {{ } => { // let return_type = wabt2rust_type(&args[0]); // let func_return = format!(" -> {}", return_type); - let assertion = String::from("assert!(result.is_quiet_nan())"); + let assertion = String::from("assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + })"); // We map the arguments provided into the raw Arguments provided // to libffi @@ -386,7 +391,11 @@ fn {}_assert_invalid() {{ _ => wabt2rust_type(&args[0]), }; // let func_return = format!(" -> {}", return_type); - let assertion = String::from("assert!(result.is_quiet_nan())"); + let assertion = String::from("assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + })"); // We map the arguments provided into the raw Arguments provided // to libffi @@ -429,7 +438,7 @@ fn {}_assert_invalid() {{ "#[test] fn {}_assert_malformed() {{ let wasm_binary = {:?}; - let compilation = wasmer_runtime::compile(wasm_binary, &CraneliftCompiler::new()); + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); assert!(compilation.is_err(), \"WASM should not compile as is malformed\"); }}\n", command_name, @@ -463,9 +472,9 @@ fn {}_assert_malformed() {{ "should not use this expect result".to_string() }; let expected_some_result = if expected.len() > 0 { - format!("Some({})", wabt2rust_value(&expected[0])) + format!("Ok(Some({}))", wabt2rust_value(&expected[0])) } else { - "None".to_string() + "Ok(None)".to_string() }; let return_type = if expected.len() > 0 { wabt2rust_type(&expected[0]) @@ -485,7 +494,7 @@ fn {}_assert_malformed() {{ let assertion = if expected.len() > 0 && is_nan(&expected[0]) { format!( "let expected = {expected_result}; - if let {return_type_destructure} = result.unwrap() {{ + if let {return_type_destructure} = result.clone().unwrap().unwrap() {{ assert!((result as {return_type}).is_nan()); assert_eq!((result as {return_type}).is_sign_positive(), (expected as {return_type}).is_sign_positive()); }} else {{ @@ -514,7 +523,7 @@ fn {}_assert_malformed() {{ format!( "fn {func_name}(instance: &mut Instance) -> Result<(), String> {{ println!(\"Executing function {{}}\", \"{func_name}\"); - let result = instance.call(\"{field}\", &[{args_values}]).expect(\"Missing result in {func_name}\"); + let result = instance.call(\"{field}\", &[{args_values}]); {assertion} result.map(|_| ()) }}\n", @@ -570,7 +579,7 @@ fn {}_assert_malformed() {{ #[test] fn {}() {{ let mut instance = create_module_{}(); - let result = {}(&mut instance); + let result = {}(&mut*instance); assert!(result.is_err()); }}\n", trap_func_name, diff --git a/lib/runtime/src/lib.rs b/lib/runtime/src/lib.rs index b467cd02b..fcbf02a5b 100644 --- a/lib/runtime/src/lib.rs +++ b/lib/runtime/src/lib.rs @@ -1,3 +1,7 @@ +#[cfg(test)] +#[macro_use] +extern crate field_offset; + #[macro_use] mod macros; mod backend; @@ -9,7 +13,7 @@ pub mod module; mod recovery; mod sig_registry; mod sighandler; -mod table; +pub mod table; pub mod types; pub mod vm; pub mod vmcalls; diff --git a/lib/runtime/tests/spectest.rs b/lib/runtime/tests/spectest.rs new file mode 100644 index 000000000..df38ac2d6 --- /dev/null +++ b/lib/runtime/tests/spectest.rs @@ -0,0 +1 @@ +mod spectests; \ No newline at end of file diff --git a/lib/runtime/tests/spectests/_common.rs b/lib/runtime/tests/spectests/_common.rs index 95825fe9d..0703dd191 100644 --- a/lib/runtime/tests/spectests/_common.rs +++ b/lib/runtime/tests/spectests/_common.rs @@ -1,5 +1,6 @@ use wasmer_runtime::types::{ElementType, FuncSig, Table, Type, Value}; -use wasmer_runtime::{Import, Imports, TableBacking, FuncRef}; +use wasmer_runtime::{Import, Imports, FuncRef}; +use wasmer_runtime::table::TableBacking; use std::sync::Arc; extern "C" fn print_i32(num: i32) { diff --git a/lib/runtime/tests/spectests/address.rs b/lib/runtime/tests/spectests/address.rs new file mode 100644 index 000000000..e831cf05c --- /dev/null +++ b/lib/runtime/tests/spectests/address.rs @@ -0,0 +1,2823 @@ +// 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/address.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 3 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func (param i32) (result i32))) + (type (;1;) (func (param i32))) + (func (;0;) (type 0) (param i32) (result i32) + get_local 0 + i32.load8_u) + (func (;1;) (type 0) (param i32) (result i32) + get_local 0 + i32.load8_u) + (func (;2;) (type 0) (param i32) (result i32) + get_local 0 + i32.load8_u offset=1) + (func (;3;) (type 0) (param i32) (result i32) + get_local 0 + i32.load8_u offset=2) + (func (;4;) (type 0) (param i32) (result i32) + get_local 0 + i32.load8_u offset=25) + (func (;5;) (type 0) (param i32) (result i32) + get_local 0 + i32.load8_s) + (func (;6;) (type 0) (param i32) (result i32) + get_local 0 + i32.load8_s) + (func (;7;) (type 0) (param i32) (result i32) + get_local 0 + i32.load8_s offset=1) + (func (;8;) (type 0) (param i32) (result i32) + get_local 0 + i32.load8_s offset=2) + (func (;9;) (type 0) (param i32) (result i32) + get_local 0 + i32.load8_s offset=25) + (func (;10;) (type 0) (param i32) (result i32) + get_local 0 + i32.load16_u) + (func (;11;) (type 0) (param i32) (result i32) + get_local 0 + i32.load16_u align=1) + (func (;12;) (type 0) (param i32) (result i32) + get_local 0 + i32.load16_u offset=1 align=1) + (func (;13;) (type 0) (param i32) (result i32) + get_local 0 + i32.load16_u offset=2) + (func (;14;) (type 0) (param i32) (result i32) + get_local 0 + i32.load16_u offset=25) + (func (;15;) (type 0) (param i32) (result i32) + get_local 0 + i32.load16_s) + (func (;16;) (type 0) (param i32) (result i32) + get_local 0 + i32.load16_s align=1) + (func (;17;) (type 0) (param i32) (result i32) + get_local 0 + i32.load16_s offset=1 align=1) + (func (;18;) (type 0) (param i32) (result i32) + get_local 0 + i32.load16_s offset=2) + (func (;19;) (type 0) (param i32) (result i32) + get_local 0 + i32.load16_s offset=25) + (func (;20;) (type 0) (param i32) (result i32) + get_local 0 + i32.load) + (func (;21;) (type 0) (param i32) (result i32) + get_local 0 + i32.load align=1) + (func (;22;) (type 0) (param i32) (result i32) + get_local 0 + i32.load offset=1 align=1) + (func (;23;) (type 0) (param i32) (result i32) + get_local 0 + i32.load offset=2 align=2) + (func (;24;) (type 0) (param i32) (result i32) + get_local 0 + i32.load offset=25) + (func (;25;) (type 1) (param i32) + get_local 0 + i32.load8_u offset=4294967295 + drop) + (func (;26;) (type 1) (param i32) + get_local 0 + i32.load8_s offset=4294967295 + drop) + (func (;27;) (type 1) (param i32) + get_local 0 + i32.load16_u offset=4294967295 + drop) + (func (;28;) (type 1) (param i32) + get_local 0 + i32.load16_s offset=4294967295 + drop) + (func (;29;) (type 1) (param i32) + get_local 0 + i32.load offset=4294967295 + drop) + (memory (;0;) 1) + (export \"8u_good1\" (func 0)) + (export \"8u_good2\" (func 1)) + (export \"8u_good3\" (func 2)) + (export \"8u_good4\" (func 3)) + (export \"8u_good5\" (func 4)) + (export \"8s_good1\" (func 5)) + (export \"8s_good2\" (func 6)) + (export \"8s_good3\" (func 7)) + (export \"8s_good4\" (func 8)) + (export \"8s_good5\" (func 9)) + (export \"16u_good1\" (func 10)) + (export \"16u_good2\" (func 11)) + (export \"16u_good3\" (func 12)) + (export \"16u_good4\" (func 13)) + (export \"16u_good5\" (func 14)) + (export \"16s_good1\" (func 15)) + (export \"16s_good2\" (func 16)) + (export \"16s_good3\" (func 17)) + (export \"16s_good4\" (func 18)) + (export \"16s_good5\" (func 19)) + (export \"32_good1\" (func 20)) + (export \"32_good2\" (func 21)) + (export \"32_good3\" (func 22)) + (export \"32_good4\" (func 23)) + (export \"32_good5\" (func 24)) + (export \"8u_bad\" (func 25)) + (export \"8s_bad\" (func 26)) + (export \"16u_bad\" (func 27)) + (export \"16s_bad\" (func 28)) + (export \"32_bad\" (func 29)) + (data (;0;) (i32.const 0) \"abcdefghijklmnopqrstuvwxyz\")) + "; + 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 104 +fn c1_l104_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l104_action_invoke"); + let result = instance.call("8u_good1", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(97 as i32)))); + result.map(|_| ()) +} + +// Line 105 +fn c2_l105_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l105_action_invoke"); + let result = instance.call("8u_good2", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(97 as i32)))); + result.map(|_| ()) +} + +// Line 106 +fn c3_l106_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l106_action_invoke"); + let result = instance.call("8u_good3", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(98 as i32)))); + result.map(|_| ()) +} + +// Line 107 +fn c4_l107_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l107_action_invoke"); + let result = instance.call("8u_good4", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(99 as i32)))); + result.map(|_| ()) +} + +// Line 108 +fn c5_l108_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l108_action_invoke"); + let result = instance.call("8u_good5", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(122 as i32)))); + result.map(|_| ()) +} + +// Line 110 +fn c6_l110_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l110_action_invoke"); + let result = instance.call("8s_good1", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(97 as i32)))); + result.map(|_| ()) +} + +// Line 111 +fn c7_l111_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l111_action_invoke"); + let result = instance.call("8s_good2", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(97 as i32)))); + result.map(|_| ()) +} + +// Line 112 +fn c8_l112_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l112_action_invoke"); + let result = instance.call("8s_good3", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(98 as i32)))); + result.map(|_| ()) +} + +// Line 113 +fn c9_l113_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l113_action_invoke"); + let result = instance.call("8s_good4", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(99 as i32)))); + result.map(|_| ()) +} + +// Line 114 +fn c10_l114_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c10_l114_action_invoke"); + let result = instance.call("8s_good5", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(122 as i32)))); + result.map(|_| ()) +} + +// Line 116 +fn c11_l116_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c11_l116_action_invoke"); + let result = instance.call("16u_good1", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(25185 as i32)))); + result.map(|_| ()) +} + +// Line 117 +fn c12_l117_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c12_l117_action_invoke"); + let result = instance.call("16u_good2", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(25185 as i32)))); + result.map(|_| ()) +} + +// Line 118 +fn c13_l118_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c13_l118_action_invoke"); + let result = instance.call("16u_good3", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(25442 as i32)))); + result.map(|_| ()) +} + +// Line 119 +fn c14_l119_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c14_l119_action_invoke"); + let result = instance.call("16u_good4", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(25699 as i32)))); + result.map(|_| ()) +} + +// Line 120 +fn c15_l120_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c15_l120_action_invoke"); + let result = instance.call("16u_good5", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(122 as i32)))); + result.map(|_| ()) +} + +// Line 122 +fn c16_l122_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c16_l122_action_invoke"); + let result = instance.call("16s_good1", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(25185 as i32)))); + result.map(|_| ()) +} + +// Line 123 +fn c17_l123_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c17_l123_action_invoke"); + let result = instance.call("16s_good2", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(25185 as i32)))); + result.map(|_| ()) +} + +// Line 124 +fn c18_l124_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c18_l124_action_invoke"); + let result = instance.call("16s_good3", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(25442 as i32)))); + result.map(|_| ()) +} + +// Line 125 +fn c19_l125_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c19_l125_action_invoke"); + let result = instance.call("16s_good4", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(25699 as i32)))); + result.map(|_| ()) +} + +// Line 126 +fn c20_l126_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c20_l126_action_invoke"); + let result = instance.call("16s_good5", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(122 as i32)))); + result.map(|_| ()) +} + +// Line 128 +fn c21_l128_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c21_l128_action_invoke"); + let result = instance.call("32_good1", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1684234849 as i32)))); + result.map(|_| ()) +} + +// Line 129 +fn c22_l129_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c22_l129_action_invoke"); + let result = instance.call("32_good2", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1684234849 as i32)))); + result.map(|_| ()) +} + +// Line 130 +fn c23_l130_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c23_l130_action_invoke"); + let result = instance.call("32_good3", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1701077858 as i32)))); + result.map(|_| ()) +} + +// Line 131 +fn c24_l131_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c24_l131_action_invoke"); + let result = instance.call("32_good4", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1717920867 as i32)))); + result.map(|_| ()) +} + +// Line 132 +fn c25_l132_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c25_l132_action_invoke"); + let result = instance.call("32_good5", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(122 as i32)))); + result.map(|_| ()) +} + +// Line 134 +fn c26_l134_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c26_l134_action_invoke"); + let result = instance.call("8u_good1", &[Value::I32(65507 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 135 +fn c27_l135_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c27_l135_action_invoke"); + let result = instance.call("8u_good2", &[Value::I32(65507 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 136 +fn c28_l136_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c28_l136_action_invoke"); + let result = instance.call("8u_good3", &[Value::I32(65507 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 137 +fn c29_l137_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c29_l137_action_invoke"); + let result = instance.call("8u_good4", &[Value::I32(65507 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 138 +fn c30_l138_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c30_l138_action_invoke"); + let result = instance.call("8u_good5", &[Value::I32(65507 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 140 +fn c31_l140_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c31_l140_action_invoke"); + let result = instance.call("8s_good1", &[Value::I32(65507 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 141 +fn c32_l141_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c32_l141_action_invoke"); + let result = instance.call("8s_good2", &[Value::I32(65507 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 142 +fn c33_l142_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c33_l142_action_invoke"); + let result = instance.call("8s_good3", &[Value::I32(65507 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 143 +fn c34_l143_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c34_l143_action_invoke"); + let result = instance.call("8s_good4", &[Value::I32(65507 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 144 +fn c35_l144_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c35_l144_action_invoke"); + let result = instance.call("8s_good5", &[Value::I32(65507 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 146 +fn c36_l146_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c36_l146_action_invoke"); + let result = instance.call("16u_good1", &[Value::I32(65507 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 147 +fn c37_l147_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c37_l147_action_invoke"); + let result = instance.call("16u_good2", &[Value::I32(65507 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 148 +fn c38_l148_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c38_l148_action_invoke"); + let result = instance.call("16u_good3", &[Value::I32(65507 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 149 +fn c39_l149_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c39_l149_action_invoke"); + let result = instance.call("16u_good4", &[Value::I32(65507 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 150 +fn c40_l150_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c40_l150_action_invoke"); + let result = instance.call("16u_good5", &[Value::I32(65507 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 152 +fn c41_l152_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c41_l152_action_invoke"); + let result = instance.call("16s_good1", &[Value::I32(65507 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 153 +fn c42_l153_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c42_l153_action_invoke"); + let result = instance.call("16s_good2", &[Value::I32(65507 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 154 +fn c43_l154_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c43_l154_action_invoke"); + let result = instance.call("16s_good3", &[Value::I32(65507 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 155 +fn c44_l155_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c44_l155_action_invoke"); + let result = instance.call("16s_good4", &[Value::I32(65507 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 156 +fn c45_l156_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c45_l156_action_invoke"); + let result = instance.call("16s_good5", &[Value::I32(65507 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 158 +fn c46_l158_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c46_l158_action_invoke"); + let result = instance.call("32_good1", &[Value::I32(65507 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 159 +fn c47_l159_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c47_l159_action_invoke"); + let result = instance.call("32_good2", &[Value::I32(65507 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 160 +fn c48_l160_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c48_l160_action_invoke"); + let result = instance.call("32_good3", &[Value::I32(65507 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 161 +fn c49_l161_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c49_l161_action_invoke"); + let result = instance.call("32_good4", &[Value::I32(65507 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 162 +fn c50_l162_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c50_l162_action_invoke"); + let result = instance.call("32_good5", &[Value::I32(65507 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 164 +fn c51_l164_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c51_l164_action_invoke"); + let result = instance.call("8u_good1", &[Value::I32(65508 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 165 +fn c52_l165_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c52_l165_action_invoke"); + let result = instance.call("8u_good2", &[Value::I32(65508 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 166 +fn c53_l166_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c53_l166_action_invoke"); + let result = instance.call("8u_good3", &[Value::I32(65508 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 167 +fn c54_l167_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c54_l167_action_invoke"); + let result = instance.call("8u_good4", &[Value::I32(65508 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 168 +fn c55_l168_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c55_l168_action_invoke"); + let result = instance.call("8u_good5", &[Value::I32(65508 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 170 +fn c56_l170_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c56_l170_action_invoke"); + let result = instance.call("8s_good1", &[Value::I32(65508 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 171 +fn c57_l171_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c57_l171_action_invoke"); + let result = instance.call("8s_good2", &[Value::I32(65508 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 172 +fn c58_l172_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c58_l172_action_invoke"); + let result = instance.call("8s_good3", &[Value::I32(65508 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 173 +fn c59_l173_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c59_l173_action_invoke"); + let result = instance.call("8s_good4", &[Value::I32(65508 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 174 +fn c60_l174_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c60_l174_action_invoke"); + let result = instance.call("8s_good5", &[Value::I32(65508 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 176 +fn c61_l176_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c61_l176_action_invoke"); + let result = instance.call("16u_good1", &[Value::I32(65508 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 177 +fn c62_l177_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c62_l177_action_invoke"); + let result = instance.call("16u_good2", &[Value::I32(65508 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 178 +fn c63_l178_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c63_l178_action_invoke"); + let result = instance.call("16u_good3", &[Value::I32(65508 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 179 +fn c64_l179_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c64_l179_action_invoke"); + let result = instance.call("16u_good4", &[Value::I32(65508 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 180 +fn c65_l180_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c65_l180_action_invoke"); + let result = instance.call("16u_good5", &[Value::I32(65508 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 182 +fn c66_l182_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c66_l182_action_invoke"); + let result = instance.call("16s_good1", &[Value::I32(65508 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 183 +fn c67_l183_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c67_l183_action_invoke"); + let result = instance.call("16s_good2", &[Value::I32(65508 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 184 +fn c68_l184_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c68_l184_action_invoke"); + let result = instance.call("16s_good3", &[Value::I32(65508 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 185 +fn c69_l185_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c69_l185_action_invoke"); + let result = instance.call("16s_good4", &[Value::I32(65508 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 186 +fn c70_l186_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c70_l186_action_invoke"); + let result = instance.call("16s_good5", &[Value::I32(65508 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 188 +fn c71_l188_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c71_l188_action_invoke"); + let result = instance.call("32_good1", &[Value::I32(65508 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 189 +fn c72_l189_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c72_l189_action_invoke"); + let result = instance.call("32_good2", &[Value::I32(65508 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 190 +fn c73_l190_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c73_l190_action_invoke"); + let result = instance.call("32_good3", &[Value::I32(65508 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 191 +fn c74_l191_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c74_l191_action_invoke"); + let result = instance.call("32_good4", &[Value::I32(65508 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 192 +fn c75_l192_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c75_l192_action_invoke"); + let result = instance.call("32_good5", &[Value::I32(65508 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c75_l192_assert_trap() { + let mut instance = create_module_1(); + let result = c75_l192_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 194 +fn c76_l194_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c76_l194_action_invoke"); + let result = instance.call("8u_bad", &[Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c76_l194_assert_trap() { + let mut instance = create_module_1(); + let result = c76_l194_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 195 +fn c77_l195_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c77_l195_action_invoke"); + let result = instance.call("8s_bad", &[Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c77_l195_assert_trap() { + let mut instance = create_module_1(); + let result = c77_l195_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 196 +fn c78_l196_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c78_l196_action_invoke"); + let result = instance.call("16u_bad", &[Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c78_l196_assert_trap() { + let mut instance = create_module_1(); + let result = c78_l196_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 197 +fn c79_l197_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c79_l197_action_invoke"); + let result = instance.call("16s_bad", &[Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c79_l197_assert_trap() { + let mut instance = create_module_1(); + let result = c79_l197_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 198 +fn c80_l198_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c80_l198_action_invoke"); + let result = instance.call("32_bad", &[Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c80_l198_assert_trap() { + let mut instance = create_module_1(); + let result = c80_l198_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 200 +fn c81_l200_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c81_l200_action_invoke"); + let result = instance.call("8u_bad", &[Value::I32(1 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c81_l200_assert_trap() { + let mut instance = create_module_1(); + let result = c81_l200_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 201 +fn c82_l201_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c82_l201_action_invoke"); + let result = instance.call("8s_bad", &[Value::I32(1 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c82_l201_assert_trap() { + let mut instance = create_module_1(); + let result = c82_l201_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 202 +fn c83_l202_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c83_l202_action_invoke"); + let result = instance.call("16u_bad", &[Value::I32(1 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c83_l202_assert_trap() { + let mut instance = create_module_1(); + let result = c83_l202_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 203 +fn c84_l203_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c84_l203_action_invoke"); + let result = instance.call("16s_bad", &[Value::I32(1 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c84_l203_assert_trap() { + let mut instance = create_module_1(); + let result = c84_l203_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 204 +fn c85_l204_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c85_l204_action_invoke"); + let result = instance.call("32_bad", &[Value::I32(1 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c85_l204_assert_trap() { + let mut instance = create_module_1(); + let result = c85_l204_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 207 +#[test] +fn c86_l207_assert_malformed() { + let wasm_binary = [40, 109, 101, 109, 111, 114, 121, 32, 49, 41, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 51, 50, 46, 108, 111, 97, 100, 32, 111, 102, 102, 115, 101, 116, 61, 52, 50, 57, 52, 57, 54, 55, 50, 57, 54, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 216 + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l104_action_invoke(&mut instance); + c2_l105_action_invoke(&mut instance); + c3_l106_action_invoke(&mut instance); + c4_l107_action_invoke(&mut instance); + c5_l108_action_invoke(&mut instance); + c6_l110_action_invoke(&mut instance); + c7_l111_action_invoke(&mut instance); + c8_l112_action_invoke(&mut instance); + c9_l113_action_invoke(&mut instance); + c10_l114_action_invoke(&mut instance); + c11_l116_action_invoke(&mut instance); + c12_l117_action_invoke(&mut instance); + c13_l118_action_invoke(&mut instance); + c14_l119_action_invoke(&mut instance); + c15_l120_action_invoke(&mut instance); + c16_l122_action_invoke(&mut instance); + c17_l123_action_invoke(&mut instance); + c18_l124_action_invoke(&mut instance); + c19_l125_action_invoke(&mut instance); + c20_l126_action_invoke(&mut instance); + c21_l128_action_invoke(&mut instance); + c22_l129_action_invoke(&mut instance); + c23_l130_action_invoke(&mut instance); + c24_l131_action_invoke(&mut instance); + c25_l132_action_invoke(&mut instance); + c26_l134_action_invoke(&mut instance); + c27_l135_action_invoke(&mut instance); + c28_l136_action_invoke(&mut instance); + c29_l137_action_invoke(&mut instance); + c30_l138_action_invoke(&mut instance); + c31_l140_action_invoke(&mut instance); + c32_l141_action_invoke(&mut instance); + c33_l142_action_invoke(&mut instance); + c34_l143_action_invoke(&mut instance); + c35_l144_action_invoke(&mut instance); + c36_l146_action_invoke(&mut instance); + c37_l147_action_invoke(&mut instance); + c38_l148_action_invoke(&mut instance); + c39_l149_action_invoke(&mut instance); + c40_l150_action_invoke(&mut instance); + c41_l152_action_invoke(&mut instance); + c42_l153_action_invoke(&mut instance); + c43_l154_action_invoke(&mut instance); + c44_l155_action_invoke(&mut instance); + c45_l156_action_invoke(&mut instance); + c46_l158_action_invoke(&mut instance); + c47_l159_action_invoke(&mut instance); + c48_l160_action_invoke(&mut instance); + c49_l161_action_invoke(&mut instance); + c50_l162_action_invoke(&mut instance); + c51_l164_action_invoke(&mut instance); + c52_l165_action_invoke(&mut instance); + c53_l166_action_invoke(&mut instance); + c54_l167_action_invoke(&mut instance); + c55_l168_action_invoke(&mut instance); + c56_l170_action_invoke(&mut instance); + c57_l171_action_invoke(&mut instance); + c58_l172_action_invoke(&mut instance); + c59_l173_action_invoke(&mut instance); + c60_l174_action_invoke(&mut instance); + c61_l176_action_invoke(&mut instance); + c62_l177_action_invoke(&mut instance); + c63_l178_action_invoke(&mut instance); + c64_l179_action_invoke(&mut instance); + c65_l180_action_invoke(&mut instance); + c66_l182_action_invoke(&mut instance); + c67_l183_action_invoke(&mut instance); + c68_l184_action_invoke(&mut instance); + c69_l185_action_invoke(&mut instance); + c70_l186_action_invoke(&mut instance); + c71_l188_action_invoke(&mut instance); + c72_l189_action_invoke(&mut instance); + c73_l190_action_invoke(&mut instance); + c74_l191_action_invoke(&mut instance); +} +fn create_module_2() -> Box { + let module_str = "(module + (type (;0;) (func (param i32) (result i64))) + (type (;1;) (func (param i32))) + (func (;0;) (type 0) (param i32) (result i64) + get_local 0 + i64.load8_u) + (func (;1;) (type 0) (param i32) (result i64) + get_local 0 + i64.load8_u) + (func (;2;) (type 0) (param i32) (result i64) + get_local 0 + i64.load8_u offset=1) + (func (;3;) (type 0) (param i32) (result i64) + get_local 0 + i64.load8_u offset=2) + (func (;4;) (type 0) (param i32) (result i64) + get_local 0 + i64.load8_u offset=25) + (func (;5;) (type 0) (param i32) (result i64) + get_local 0 + i64.load8_s) + (func (;6;) (type 0) (param i32) (result i64) + get_local 0 + i64.load8_s) + (func (;7;) (type 0) (param i32) (result i64) + get_local 0 + i64.load8_s offset=1) + (func (;8;) (type 0) (param i32) (result i64) + get_local 0 + i64.load8_s offset=2) + (func (;9;) (type 0) (param i32) (result i64) + get_local 0 + i64.load8_s offset=25) + (func (;10;) (type 0) (param i32) (result i64) + get_local 0 + i64.load16_u) + (func (;11;) (type 0) (param i32) (result i64) + get_local 0 + i64.load16_u align=1) + (func (;12;) (type 0) (param i32) (result i64) + get_local 0 + i64.load16_u offset=1 align=1) + (func (;13;) (type 0) (param i32) (result i64) + get_local 0 + i64.load16_u offset=2) + (func (;14;) (type 0) (param i32) (result i64) + get_local 0 + i64.load16_u offset=25) + (func (;15;) (type 0) (param i32) (result i64) + get_local 0 + i64.load16_s) + (func (;16;) (type 0) (param i32) (result i64) + get_local 0 + i64.load16_s align=1) + (func (;17;) (type 0) (param i32) (result i64) + get_local 0 + i64.load16_s offset=1 align=1) + (func (;18;) (type 0) (param i32) (result i64) + get_local 0 + i64.load16_s offset=2) + (func (;19;) (type 0) (param i32) (result i64) + get_local 0 + i64.load16_s offset=25) + (func (;20;) (type 0) (param i32) (result i64) + get_local 0 + i64.load32_u) + (func (;21;) (type 0) (param i32) (result i64) + get_local 0 + i64.load32_u align=1) + (func (;22;) (type 0) (param i32) (result i64) + get_local 0 + i64.load32_u offset=1 align=1) + (func (;23;) (type 0) (param i32) (result i64) + get_local 0 + i64.load32_u offset=2 align=2) + (func (;24;) (type 0) (param i32) (result i64) + get_local 0 + i64.load32_u offset=25) + (func (;25;) (type 0) (param i32) (result i64) + get_local 0 + i64.load32_s) + (func (;26;) (type 0) (param i32) (result i64) + get_local 0 + i64.load32_s align=1) + (func (;27;) (type 0) (param i32) (result i64) + get_local 0 + i64.load32_s offset=1 align=1) + (func (;28;) (type 0) (param i32) (result i64) + get_local 0 + i64.load32_s offset=2 align=2) + (func (;29;) (type 0) (param i32) (result i64) + get_local 0 + i64.load32_s offset=25) + (func (;30;) (type 0) (param i32) (result i64) + get_local 0 + i64.load) + (func (;31;) (type 0) (param i32) (result i64) + get_local 0 + i64.load align=1) + (func (;32;) (type 0) (param i32) (result i64) + get_local 0 + i64.load offset=1 align=1) + (func (;33;) (type 0) (param i32) (result i64) + get_local 0 + i64.load offset=2 align=2) + (func (;34;) (type 0) (param i32) (result i64) + get_local 0 + i64.load offset=25) + (func (;35;) (type 1) (param i32) + get_local 0 + i64.load8_u offset=4294967295 + drop) + (func (;36;) (type 1) (param i32) + get_local 0 + i64.load8_s offset=4294967295 + drop) + (func (;37;) (type 1) (param i32) + get_local 0 + i64.load16_u offset=4294967295 + drop) + (func (;38;) (type 1) (param i32) + get_local 0 + i64.load16_s offset=4294967295 + drop) + (func (;39;) (type 1) (param i32) + get_local 0 + i64.load32_u offset=4294967295 + drop) + (func (;40;) (type 1) (param i32) + get_local 0 + i64.load32_s offset=4294967295 + drop) + (func (;41;) (type 1) (param i32) + get_local 0 + i64.load offset=4294967295 + drop) + (memory (;0;) 1) + (export \"8u_good1\" (func 0)) + (export \"8u_good2\" (func 1)) + (export \"8u_good3\" (func 2)) + (export \"8u_good4\" (func 3)) + (export \"8u_good5\" (func 4)) + (export \"8s_good1\" (func 5)) + (export \"8s_good2\" (func 6)) + (export \"8s_good3\" (func 7)) + (export \"8s_good4\" (func 8)) + (export \"8s_good5\" (func 9)) + (export \"16u_good1\" (func 10)) + (export \"16u_good2\" (func 11)) + (export \"16u_good3\" (func 12)) + (export \"16u_good4\" (func 13)) + (export \"16u_good5\" (func 14)) + (export \"16s_good1\" (func 15)) + (export \"16s_good2\" (func 16)) + (export \"16s_good3\" (func 17)) + (export \"16s_good4\" (func 18)) + (export \"16s_good5\" (func 19)) + (export \"32u_good1\" (func 20)) + (export \"32u_good2\" (func 21)) + (export \"32u_good3\" (func 22)) + (export \"32u_good4\" (func 23)) + (export \"32u_good5\" (func 24)) + (export \"32s_good1\" (func 25)) + (export \"32s_good2\" (func 26)) + (export \"32s_good3\" (func 27)) + (export \"32s_good4\" (func 28)) + (export \"32s_good5\" (func 29)) + (export \"64_good1\" (func 30)) + (export \"64_good2\" (func 31)) + (export \"64_good3\" (func 32)) + (export \"64_good4\" (func 33)) + (export \"64_good5\" (func 34)) + (export \"8u_bad\" (func 35)) + (export \"8s_bad\" (func 36)) + (export \"16u_bad\" (func 37)) + (export \"16s_bad\" (func 38)) + (export \"32u_bad\" (func 39)) + (export \"32s_bad\" (func 40)) + (export \"64_bad\" (func 41)) + (data (;0;) (i32.const 0) \"abcdefghijklmnopqrstuvwxyz\")) + "; + 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_2(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 355 +fn c88_l355_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c88_l355_action_invoke"); + let result = instance.call("8u_good1", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(97 as i64)))); + result.map(|_| ()) +} + +// Line 356 +fn c89_l356_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c89_l356_action_invoke"); + let result = instance.call("8u_good2", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(97 as i64)))); + result.map(|_| ()) +} + +// Line 357 +fn c90_l357_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c90_l357_action_invoke"); + let result = instance.call("8u_good3", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(98 as i64)))); + result.map(|_| ()) +} + +// Line 358 +fn c91_l358_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c91_l358_action_invoke"); + let result = instance.call("8u_good4", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(99 as i64)))); + result.map(|_| ()) +} + +// Line 359 +fn c92_l359_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c92_l359_action_invoke"); + let result = instance.call("8u_good5", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(122 as i64)))); + result.map(|_| ()) +} + +// Line 361 +fn c93_l361_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c93_l361_action_invoke"); + let result = instance.call("8s_good1", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(97 as i64)))); + result.map(|_| ()) +} + +// Line 362 +fn c94_l362_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c94_l362_action_invoke"); + let result = instance.call("8s_good2", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(97 as i64)))); + result.map(|_| ()) +} + +// Line 363 +fn c95_l363_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c95_l363_action_invoke"); + let result = instance.call("8s_good3", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(98 as i64)))); + result.map(|_| ()) +} + +// Line 364 +fn c96_l364_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c96_l364_action_invoke"); + let result = instance.call("8s_good4", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(99 as i64)))); + result.map(|_| ()) +} + +// Line 365 +fn c97_l365_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c97_l365_action_invoke"); + let result = instance.call("8s_good5", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(122 as i64)))); + result.map(|_| ()) +} + +// Line 367 +fn c98_l367_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c98_l367_action_invoke"); + let result = instance.call("16u_good1", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(25185 as i64)))); + result.map(|_| ()) +} + +// Line 368 +fn c99_l368_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c99_l368_action_invoke"); + let result = instance.call("16u_good2", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(25185 as i64)))); + result.map(|_| ()) +} + +// Line 369 +fn c100_l369_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c100_l369_action_invoke"); + let result = instance.call("16u_good3", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(25442 as i64)))); + result.map(|_| ()) +} + +// Line 370 +fn c101_l370_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c101_l370_action_invoke"); + let result = instance.call("16u_good4", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(25699 as i64)))); + result.map(|_| ()) +} + +// Line 371 +fn c102_l371_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c102_l371_action_invoke"); + let result = instance.call("16u_good5", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(122 as i64)))); + result.map(|_| ()) +} + +// Line 373 +fn c103_l373_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c103_l373_action_invoke"); + let result = instance.call("16s_good1", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(25185 as i64)))); + result.map(|_| ()) +} + +// Line 374 +fn c104_l374_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c104_l374_action_invoke"); + let result = instance.call("16s_good2", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(25185 as i64)))); + result.map(|_| ()) +} + +// Line 375 +fn c105_l375_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c105_l375_action_invoke"); + let result = instance.call("16s_good3", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(25442 as i64)))); + result.map(|_| ()) +} + +// Line 376 +fn c106_l376_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c106_l376_action_invoke"); + let result = instance.call("16s_good4", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(25699 as i64)))); + result.map(|_| ()) +} + +// Line 377 +fn c107_l377_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c107_l377_action_invoke"); + let result = instance.call("16s_good5", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(122 as i64)))); + result.map(|_| ()) +} + +// Line 379 +fn c108_l379_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c108_l379_action_invoke"); + let result = instance.call("32u_good1", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(1684234849 as i64)))); + result.map(|_| ()) +} + +// Line 380 +fn c109_l380_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c109_l380_action_invoke"); + let result = instance.call("32u_good2", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(1684234849 as i64)))); + result.map(|_| ()) +} + +// Line 381 +fn c110_l381_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c110_l381_action_invoke"); + let result = instance.call("32u_good3", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(1701077858 as i64)))); + result.map(|_| ()) +} + +// Line 382 +fn c111_l382_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c111_l382_action_invoke"); + let result = instance.call("32u_good4", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(1717920867 as i64)))); + result.map(|_| ()) +} + +// Line 383 +fn c112_l383_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c112_l383_action_invoke"); + let result = instance.call("32u_good5", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(122 as i64)))); + result.map(|_| ()) +} + +// Line 385 +fn c113_l385_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c113_l385_action_invoke"); + let result = instance.call("32s_good1", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(1684234849 as i64)))); + result.map(|_| ()) +} + +// Line 386 +fn c114_l386_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c114_l386_action_invoke"); + let result = instance.call("32s_good2", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(1684234849 as i64)))); + result.map(|_| ()) +} + +// Line 387 +fn c115_l387_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c115_l387_action_invoke"); + let result = instance.call("32s_good3", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(1701077858 as i64)))); + result.map(|_| ()) +} + +// Line 388 +fn c116_l388_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c116_l388_action_invoke"); + let result = instance.call("32s_good4", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(1717920867 as i64)))); + result.map(|_| ()) +} + +// Line 389 +fn c117_l389_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c117_l389_action_invoke"); + let result = instance.call("32s_good5", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(122 as i64)))); + result.map(|_| ()) +} + +// Line 391 +fn c118_l391_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c118_l391_action_invoke"); + let result = instance.call("64_good1", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(7523094288207667809 as i64)))); + result.map(|_| ()) +} + +// Line 392 +fn c119_l392_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c119_l392_action_invoke"); + let result = instance.call("64_good2", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(7523094288207667809 as i64)))); + result.map(|_| ()) +} + +// Line 393 +fn c120_l393_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c120_l393_action_invoke"); + let result = instance.call("64_good3", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(7595434461045744482 as i64)))); + result.map(|_| ()) +} + +// Line 394 +fn c121_l394_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c121_l394_action_invoke"); + let result = instance.call("64_good4", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(7667774633883821155 as i64)))); + result.map(|_| ()) +} + +// Line 395 +fn c122_l395_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c122_l395_action_invoke"); + let result = instance.call("64_good5", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(122 as i64)))); + result.map(|_| ()) +} + +// Line 397 +fn c123_l397_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c123_l397_action_invoke"); + let result = instance.call("8u_good1", &[Value::I32(65503 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 398 +fn c124_l398_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c124_l398_action_invoke"); + let result = instance.call("8u_good2", &[Value::I32(65503 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 399 +fn c125_l399_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c125_l399_action_invoke"); + let result = instance.call("8u_good3", &[Value::I32(65503 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 400 +fn c126_l400_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c126_l400_action_invoke"); + let result = instance.call("8u_good4", &[Value::I32(65503 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 401 +fn c127_l401_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c127_l401_action_invoke"); + let result = instance.call("8u_good5", &[Value::I32(65503 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 403 +fn c128_l403_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c128_l403_action_invoke"); + let result = instance.call("8s_good1", &[Value::I32(65503 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 404 +fn c129_l404_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c129_l404_action_invoke"); + let result = instance.call("8s_good2", &[Value::I32(65503 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 405 +fn c130_l405_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c130_l405_action_invoke"); + let result = instance.call("8s_good3", &[Value::I32(65503 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 406 +fn c131_l406_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c131_l406_action_invoke"); + let result = instance.call("8s_good4", &[Value::I32(65503 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 407 +fn c132_l407_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c132_l407_action_invoke"); + let result = instance.call("8s_good5", &[Value::I32(65503 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 409 +fn c133_l409_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c133_l409_action_invoke"); + let result = instance.call("16u_good1", &[Value::I32(65503 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 410 +fn c134_l410_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c134_l410_action_invoke"); + let result = instance.call("16u_good2", &[Value::I32(65503 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 411 +fn c135_l411_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c135_l411_action_invoke"); + let result = instance.call("16u_good3", &[Value::I32(65503 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 412 +fn c136_l412_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c136_l412_action_invoke"); + let result = instance.call("16u_good4", &[Value::I32(65503 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 413 +fn c137_l413_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c137_l413_action_invoke"); + let result = instance.call("16u_good5", &[Value::I32(65503 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 415 +fn c138_l415_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c138_l415_action_invoke"); + let result = instance.call("16s_good1", &[Value::I32(65503 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 416 +fn c139_l416_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c139_l416_action_invoke"); + let result = instance.call("16s_good2", &[Value::I32(65503 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 417 +fn c140_l417_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c140_l417_action_invoke"); + let result = instance.call("16s_good3", &[Value::I32(65503 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 418 +fn c141_l418_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c141_l418_action_invoke"); + let result = instance.call("16s_good4", &[Value::I32(65503 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 419 +fn c142_l419_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c142_l419_action_invoke"); + let result = instance.call("16s_good5", &[Value::I32(65503 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 421 +fn c143_l421_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c143_l421_action_invoke"); + let result = instance.call("32u_good1", &[Value::I32(65503 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 422 +fn c144_l422_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c144_l422_action_invoke"); + let result = instance.call("32u_good2", &[Value::I32(65503 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 423 +fn c145_l423_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c145_l423_action_invoke"); + let result = instance.call("32u_good3", &[Value::I32(65503 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 424 +fn c146_l424_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c146_l424_action_invoke"); + let result = instance.call("32u_good4", &[Value::I32(65503 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 425 +fn c147_l425_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c147_l425_action_invoke"); + let result = instance.call("32u_good5", &[Value::I32(65503 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 427 +fn c148_l427_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c148_l427_action_invoke"); + let result = instance.call("32s_good1", &[Value::I32(65503 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 428 +fn c149_l428_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c149_l428_action_invoke"); + let result = instance.call("32s_good2", &[Value::I32(65503 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 429 +fn c150_l429_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c150_l429_action_invoke"); + let result = instance.call("32s_good3", &[Value::I32(65503 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 430 +fn c151_l430_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c151_l430_action_invoke"); + let result = instance.call("32s_good4", &[Value::I32(65503 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 431 +fn c152_l431_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c152_l431_action_invoke"); + let result = instance.call("32s_good5", &[Value::I32(65503 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 433 +fn c153_l433_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c153_l433_action_invoke"); + let result = instance.call("64_good1", &[Value::I32(65503 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 434 +fn c154_l434_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c154_l434_action_invoke"); + let result = instance.call("64_good2", &[Value::I32(65503 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 435 +fn c155_l435_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c155_l435_action_invoke"); + let result = instance.call("64_good3", &[Value::I32(65503 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 436 +fn c156_l436_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c156_l436_action_invoke"); + let result = instance.call("64_good4", &[Value::I32(65503 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 437 +fn c157_l437_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c157_l437_action_invoke"); + let result = instance.call("64_good5", &[Value::I32(65503 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 439 +fn c158_l439_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c158_l439_action_invoke"); + let result = instance.call("8u_good1", &[Value::I32(65504 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 440 +fn c159_l440_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c159_l440_action_invoke"); + let result = instance.call("8u_good2", &[Value::I32(65504 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 441 +fn c160_l441_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c160_l441_action_invoke"); + let result = instance.call("8u_good3", &[Value::I32(65504 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 442 +fn c161_l442_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c161_l442_action_invoke"); + let result = instance.call("8u_good4", &[Value::I32(65504 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 443 +fn c162_l443_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c162_l443_action_invoke"); + let result = instance.call("8u_good5", &[Value::I32(65504 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 445 +fn c163_l445_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c163_l445_action_invoke"); + let result = instance.call("8s_good1", &[Value::I32(65504 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 446 +fn c164_l446_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c164_l446_action_invoke"); + let result = instance.call("8s_good2", &[Value::I32(65504 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 447 +fn c165_l447_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c165_l447_action_invoke"); + let result = instance.call("8s_good3", &[Value::I32(65504 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 448 +fn c166_l448_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c166_l448_action_invoke"); + let result = instance.call("8s_good4", &[Value::I32(65504 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 449 +fn c167_l449_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c167_l449_action_invoke"); + let result = instance.call("8s_good5", &[Value::I32(65504 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 451 +fn c168_l451_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c168_l451_action_invoke"); + let result = instance.call("16u_good1", &[Value::I32(65504 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 452 +fn c169_l452_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c169_l452_action_invoke"); + let result = instance.call("16u_good2", &[Value::I32(65504 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 453 +fn c170_l453_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c170_l453_action_invoke"); + let result = instance.call("16u_good3", &[Value::I32(65504 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 454 +fn c171_l454_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c171_l454_action_invoke"); + let result = instance.call("16u_good4", &[Value::I32(65504 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 455 +fn c172_l455_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c172_l455_action_invoke"); + let result = instance.call("16u_good5", &[Value::I32(65504 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 457 +fn c173_l457_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c173_l457_action_invoke"); + let result = instance.call("16s_good1", &[Value::I32(65504 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 458 +fn c174_l458_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c174_l458_action_invoke"); + let result = instance.call("16s_good2", &[Value::I32(65504 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 459 +fn c175_l459_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c175_l459_action_invoke"); + let result = instance.call("16s_good3", &[Value::I32(65504 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 460 +fn c176_l460_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c176_l460_action_invoke"); + let result = instance.call("16s_good4", &[Value::I32(65504 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 461 +fn c177_l461_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c177_l461_action_invoke"); + let result = instance.call("16s_good5", &[Value::I32(65504 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 463 +fn c178_l463_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c178_l463_action_invoke"); + let result = instance.call("32u_good1", &[Value::I32(65504 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 464 +fn c179_l464_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c179_l464_action_invoke"); + let result = instance.call("32u_good2", &[Value::I32(65504 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 465 +fn c180_l465_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c180_l465_action_invoke"); + let result = instance.call("32u_good3", &[Value::I32(65504 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 466 +fn c181_l466_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c181_l466_action_invoke"); + let result = instance.call("32u_good4", &[Value::I32(65504 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 467 +fn c182_l467_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c182_l467_action_invoke"); + let result = instance.call("32u_good5", &[Value::I32(65504 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 469 +fn c183_l469_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c183_l469_action_invoke"); + let result = instance.call("32s_good1", &[Value::I32(65504 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 470 +fn c184_l470_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c184_l470_action_invoke"); + let result = instance.call("32s_good2", &[Value::I32(65504 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 471 +fn c185_l471_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c185_l471_action_invoke"); + let result = instance.call("32s_good3", &[Value::I32(65504 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 472 +fn c186_l472_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c186_l472_action_invoke"); + let result = instance.call("32s_good4", &[Value::I32(65504 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 473 +fn c187_l473_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c187_l473_action_invoke"); + let result = instance.call("32s_good5", &[Value::I32(65504 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 475 +fn c188_l475_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c188_l475_action_invoke"); + let result = instance.call("64_good1", &[Value::I32(65504 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 476 +fn c189_l476_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c189_l476_action_invoke"); + let result = instance.call("64_good2", &[Value::I32(65504 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 477 +fn c190_l477_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c190_l477_action_invoke"); + let result = instance.call("64_good3", &[Value::I32(65504 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 478 +fn c191_l478_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c191_l478_action_invoke"); + let result = instance.call("64_good4", &[Value::I32(65504 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 479 +fn c192_l479_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c192_l479_action_invoke"); + let result = instance.call("64_good5", &[Value::I32(65504 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c192_l479_assert_trap() { + let mut instance = create_module_2(); + let result = c192_l479_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 481 +fn c193_l481_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c193_l481_action_invoke"); + let result = instance.call("8u_bad", &[Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c193_l481_assert_trap() { + let mut instance = create_module_2(); + let result = c193_l481_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 482 +fn c194_l482_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c194_l482_action_invoke"); + let result = instance.call("8s_bad", &[Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c194_l482_assert_trap() { + let mut instance = create_module_2(); + let result = c194_l482_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 483 +fn c195_l483_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c195_l483_action_invoke"); + let result = instance.call("16u_bad", &[Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c195_l483_assert_trap() { + let mut instance = create_module_2(); + let result = c195_l483_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 484 +fn c196_l484_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c196_l484_action_invoke"); + let result = instance.call("16s_bad", &[Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c196_l484_assert_trap() { + let mut instance = create_module_2(); + let result = c196_l484_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 485 +fn c197_l485_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c197_l485_action_invoke"); + let result = instance.call("32u_bad", &[Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c197_l485_assert_trap() { + let mut instance = create_module_2(); + let result = c197_l485_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 486 +fn c198_l486_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c198_l486_action_invoke"); + let result = instance.call("32s_bad", &[Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c198_l486_assert_trap() { + let mut instance = create_module_2(); + let result = c198_l486_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 487 +fn c199_l487_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c199_l487_action_invoke"); + let result = instance.call("64_bad", &[Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c199_l487_assert_trap() { + let mut instance = create_module_2(); + let result = c199_l487_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 489 +fn c200_l489_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c200_l489_action_invoke"); + let result = instance.call("8u_bad", &[Value::I32(1 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c200_l489_assert_trap() { + let mut instance = create_module_2(); + let result = c200_l489_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 490 +fn c201_l490_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c201_l490_action_invoke"); + let result = instance.call("8s_bad", &[Value::I32(1 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c201_l490_assert_trap() { + let mut instance = create_module_2(); + let result = c201_l490_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 491 +fn c202_l491_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c202_l491_action_invoke"); + let result = instance.call("16u_bad", &[Value::I32(1 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c202_l491_assert_trap() { + let mut instance = create_module_2(); + let result = c202_l491_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 492 +fn c203_l492_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c203_l492_action_invoke"); + let result = instance.call("16s_bad", &[Value::I32(1 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c203_l492_assert_trap() { + let mut instance = create_module_2(); + let result = c203_l492_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 493 +fn c204_l493_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c204_l493_action_invoke"); + let result = instance.call("32u_bad", &[Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c204_l493_assert_trap() { + let mut instance = create_module_2(); + let result = c204_l493_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 494 +fn c205_l494_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c205_l494_action_invoke"); + let result = instance.call("32s_bad", &[Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c205_l494_assert_trap() { + let mut instance = create_module_2(); + let result = c205_l494_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 495 +fn c206_l495_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c206_l495_action_invoke"); + let result = instance.call("64_bad", &[Value::I32(1 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c206_l495_assert_trap() { + let mut instance = create_module_2(); + let result = c206_l495_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 499 + +#[test] +fn test_module_2() { + let mut instance = create_module_2(); + // We group the calls together + start_module_2(&mut instance); + c88_l355_action_invoke(&mut instance); + c89_l356_action_invoke(&mut instance); + c90_l357_action_invoke(&mut instance); + c91_l358_action_invoke(&mut instance); + c92_l359_action_invoke(&mut instance); + c93_l361_action_invoke(&mut instance); + c94_l362_action_invoke(&mut instance); + c95_l363_action_invoke(&mut instance); + c96_l364_action_invoke(&mut instance); + c97_l365_action_invoke(&mut instance); + c98_l367_action_invoke(&mut instance); + c99_l368_action_invoke(&mut instance); + c100_l369_action_invoke(&mut instance); + c101_l370_action_invoke(&mut instance); + c102_l371_action_invoke(&mut instance); + c103_l373_action_invoke(&mut instance); + c104_l374_action_invoke(&mut instance); + c105_l375_action_invoke(&mut instance); + c106_l376_action_invoke(&mut instance); + c107_l377_action_invoke(&mut instance); + c108_l379_action_invoke(&mut instance); + c109_l380_action_invoke(&mut instance); + c110_l381_action_invoke(&mut instance); + c111_l382_action_invoke(&mut instance); + c112_l383_action_invoke(&mut instance); + c113_l385_action_invoke(&mut instance); + c114_l386_action_invoke(&mut instance); + c115_l387_action_invoke(&mut instance); + c116_l388_action_invoke(&mut instance); + c117_l389_action_invoke(&mut instance); + c118_l391_action_invoke(&mut instance); + c119_l392_action_invoke(&mut instance); + c120_l393_action_invoke(&mut instance); + c121_l394_action_invoke(&mut instance); + c122_l395_action_invoke(&mut instance); + c123_l397_action_invoke(&mut instance); + c124_l398_action_invoke(&mut instance); + c125_l399_action_invoke(&mut instance); + c126_l400_action_invoke(&mut instance); + c127_l401_action_invoke(&mut instance); + c128_l403_action_invoke(&mut instance); + c129_l404_action_invoke(&mut instance); + c130_l405_action_invoke(&mut instance); + c131_l406_action_invoke(&mut instance); + c132_l407_action_invoke(&mut instance); + c133_l409_action_invoke(&mut instance); + c134_l410_action_invoke(&mut instance); + c135_l411_action_invoke(&mut instance); + c136_l412_action_invoke(&mut instance); + c137_l413_action_invoke(&mut instance); + c138_l415_action_invoke(&mut instance); + c139_l416_action_invoke(&mut instance); + c140_l417_action_invoke(&mut instance); + c141_l418_action_invoke(&mut instance); + c142_l419_action_invoke(&mut instance); + c143_l421_action_invoke(&mut instance); + c144_l422_action_invoke(&mut instance); + c145_l423_action_invoke(&mut instance); + c146_l424_action_invoke(&mut instance); + c147_l425_action_invoke(&mut instance); + c148_l427_action_invoke(&mut instance); + c149_l428_action_invoke(&mut instance); + c150_l429_action_invoke(&mut instance); + c151_l430_action_invoke(&mut instance); + c152_l431_action_invoke(&mut instance); + c153_l433_action_invoke(&mut instance); + c154_l434_action_invoke(&mut instance); + c155_l435_action_invoke(&mut instance); + c156_l436_action_invoke(&mut instance); + c157_l437_action_invoke(&mut instance); + c158_l439_action_invoke(&mut instance); + c159_l440_action_invoke(&mut instance); + c160_l441_action_invoke(&mut instance); + c161_l442_action_invoke(&mut instance); + c162_l443_action_invoke(&mut instance); + c163_l445_action_invoke(&mut instance); + c164_l446_action_invoke(&mut instance); + c165_l447_action_invoke(&mut instance); + c166_l448_action_invoke(&mut instance); + c167_l449_action_invoke(&mut instance); + c168_l451_action_invoke(&mut instance); + c169_l452_action_invoke(&mut instance); + c170_l453_action_invoke(&mut instance); + c171_l454_action_invoke(&mut instance); + c172_l455_action_invoke(&mut instance); + c173_l457_action_invoke(&mut instance); + c174_l458_action_invoke(&mut instance); + c175_l459_action_invoke(&mut instance); + c176_l460_action_invoke(&mut instance); + c177_l461_action_invoke(&mut instance); + c178_l463_action_invoke(&mut instance); + c179_l464_action_invoke(&mut instance); + c180_l465_action_invoke(&mut instance); + c181_l466_action_invoke(&mut instance); + c182_l467_action_invoke(&mut instance); + c183_l469_action_invoke(&mut instance); + c184_l470_action_invoke(&mut instance); + c185_l471_action_invoke(&mut instance); + c186_l472_action_invoke(&mut instance); + c187_l473_action_invoke(&mut instance); + c188_l475_action_invoke(&mut instance); + c189_l476_action_invoke(&mut instance); + c190_l477_action_invoke(&mut instance); + c191_l478_action_invoke(&mut instance); +} +fn create_module_3() -> Box { + let module_str = "(module + (type (;0;) (func (param i32) (result f32))) + (type (;1;) (func (param i32))) + (func (;0;) (type 0) (param i32) (result f32) + get_local 0 + f32.load) + (func (;1;) (type 0) (param i32) (result f32) + get_local 0 + f32.load align=1) + (func (;2;) (type 0) (param i32) (result f32) + get_local 0 + f32.load offset=1 align=1) + (func (;3;) (type 0) (param i32) (result f32) + get_local 0 + f32.load offset=2 align=2) + (func (;4;) (type 0) (param i32) (result f32) + get_local 0 + f32.load offset=8) + (func (;5;) (type 1) (param i32) + get_local 0 + f32.load offset=4294967295 + drop) + (memory (;0;) 1) + (export \"32_good1\" (func 0)) + (export \"32_good2\" (func 1)) + (export \"32_good3\" (func 2)) + (export \"32_good4\" (func 3)) + (export \"32_good5\" (func 4)) + (export \"32_bad\" (func 5)) + (data (;0;) (i32.const 0) \"\\00\\00\\00\\00\\00\\00\\a0\\7f\\01\\00\\d0\\7f\")) + "; + 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_3(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 523 +fn c208_l523_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c208_l523_action_invoke"); + let result = instance.call("32_good1", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 524 +fn c209_l524_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c209_l524_action_invoke"); + let result = instance.call("32_good2", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 525 +fn c210_l525_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c210_l525_action_invoke"); + let result = instance.call("32_good3", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 526 +fn c211_l526_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c211_l526_action_invoke"); + let result = instance.call("32_good4", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 527 +fn c212_l527_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c212_l527_action_invoke"); + let result = instance.call("32_good5", &[Value::I32(0 as i32)]); + let expected = f32::from_bits(2144337921); + 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 529 +fn c213_l529_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c213_l529_action_invoke"); + let result = instance.call("32_good1", &[Value::I32(65524 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 530 +fn c214_l530_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c214_l530_action_invoke"); + let result = instance.call("32_good2", &[Value::I32(65524 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 531 +fn c215_l531_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c215_l531_action_invoke"); + let result = instance.call("32_good3", &[Value::I32(65524 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 532 +fn c216_l532_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c216_l532_action_invoke"); + let result = instance.call("32_good4", &[Value::I32(65524 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 533 +fn c217_l533_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c217_l533_action_invoke"); + let result = instance.call("32_good5", &[Value::I32(65524 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 535 +fn c218_l535_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c218_l535_action_invoke"); + let result = instance.call("32_good1", &[Value::I32(65525 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 536 +fn c219_l536_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c219_l536_action_invoke"); + let result = instance.call("32_good2", &[Value::I32(65525 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 537 +fn c220_l537_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c220_l537_action_invoke"); + let result = instance.call("32_good3", &[Value::I32(65525 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 538 +fn c221_l538_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c221_l538_action_invoke"); + let result = instance.call("32_good4", &[Value::I32(65525 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 539 +fn c222_l539_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c222_l539_action_invoke"); + let result = instance.call("32_good5", &[Value::I32(65525 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c222_l539_assert_trap() { + let mut instance = create_module_3(); + let result = c222_l539_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 541 +fn c223_l541_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c223_l541_action_invoke"); + let result = instance.call("32_bad", &[Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c223_l541_assert_trap() { + let mut instance = create_module_3(); + let result = c223_l541_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 542 +fn c224_l542_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c224_l542_action_invoke"); + let result = instance.call("32_bad", &[Value::I32(1 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c224_l542_assert_trap() { + let mut instance = create_module_3(); + let result = c224_l542_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 546 + +#[test] +fn test_module_3() { + let mut instance = create_module_3(); + // We group the calls together + start_module_3(&mut instance); + c208_l523_action_invoke(&mut instance); + c209_l524_action_invoke(&mut instance); + c210_l525_action_invoke(&mut instance); + c211_l526_action_invoke(&mut instance); + c212_l527_action_invoke(&mut instance); + c213_l529_action_invoke(&mut instance); + c214_l530_action_invoke(&mut instance); + c215_l531_action_invoke(&mut instance); + c216_l532_action_invoke(&mut instance); + c217_l533_action_invoke(&mut instance); + c218_l535_action_invoke(&mut instance); + c219_l536_action_invoke(&mut instance); + c220_l537_action_invoke(&mut instance); + c221_l538_action_invoke(&mut instance); +} +fn create_module_4() -> Box { + let module_str = "(module + (type (;0;) (func (param i32) (result f64))) + (type (;1;) (func (param i32))) + (func (;0;) (type 0) (param i32) (result f64) + get_local 0 + f64.load) + (func (;1;) (type 0) (param i32) (result f64) + get_local 0 + f64.load align=1) + (func (;2;) (type 0) (param i32) (result f64) + get_local 0 + f64.load offset=1 align=1) + (func (;3;) (type 0) (param i32) (result f64) + get_local 0 + f64.load offset=2 align=2) + (func (;4;) (type 0) (param i32) (result f64) + get_local 0 + f64.load offset=18) + (func (;5;) (type 1) (param i32) + get_local 0 + f64.load offset=4294967295 + drop) + (memory (;0;) 1) + (export \"64_good1\" (func 0)) + (export \"64_good2\" (func 1)) + (export \"64_good3\" (func 2)) + (export \"64_good4\" (func 3)) + (export \"64_good5\" (func 4)) + (export \"64_bad\" (func 5)) + (data (;0;) (i32.const 0) \"\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\f4\\7f\\01\\00\\00\\00\\00\\00\\fc\\7f\")) + "; + 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_4(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 570 +fn c226_l570_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c226_l570_action_invoke"); + let result = instance.call("64_good1", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 571 +fn c227_l571_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c227_l571_action_invoke"); + let result = instance.call("64_good2", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 572 +fn c228_l572_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c228_l572_action_invoke"); + let result = instance.call("64_good3", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 573 +fn c229_l573_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c229_l573_action_invoke"); + let result = instance.call("64_good4", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 574 +fn c230_l574_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c230_l574_action_invoke"); + let result = instance.call("64_good5", &[Value::I32(0 as i32)]); + let expected = f64::from_bits(9222246136947933185); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 576 +fn c231_l576_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c231_l576_action_invoke"); + let result = instance.call("64_good1", &[Value::I32(65510 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 577 +fn c232_l577_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c232_l577_action_invoke"); + let result = instance.call("64_good2", &[Value::I32(65510 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 578 +fn c233_l578_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c233_l578_action_invoke"); + let result = instance.call("64_good3", &[Value::I32(65510 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 579 +fn c234_l579_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c234_l579_action_invoke"); + let result = instance.call("64_good4", &[Value::I32(65510 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 580 +fn c235_l580_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c235_l580_action_invoke"); + let result = instance.call("64_good5", &[Value::I32(65510 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 582 +fn c236_l582_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c236_l582_action_invoke"); + let result = instance.call("64_good1", &[Value::I32(65511 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 583 +fn c237_l583_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c237_l583_action_invoke"); + let result = instance.call("64_good2", &[Value::I32(65511 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 584 +fn c238_l584_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c238_l584_action_invoke"); + let result = instance.call("64_good3", &[Value::I32(65511 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 585 +fn c239_l585_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c239_l585_action_invoke"); + let result = instance.call("64_good4", &[Value::I32(65511 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 586 +fn c240_l586_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c240_l586_action_invoke"); + let result = instance.call("64_good5", &[Value::I32(65511 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c240_l586_assert_trap() { + let mut instance = create_module_4(); + let result = c240_l586_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 588 +fn c241_l588_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c241_l588_action_invoke"); + let result = instance.call("64_bad", &[Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c241_l588_assert_trap() { + let mut instance = create_module_4(); + let result = c241_l588_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 589 +fn c242_l589_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c242_l589_action_invoke"); + let result = instance.call("64_bad", &[Value::I32(1 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c242_l589_assert_trap() { + let mut instance = create_module_4(); + let result = c242_l589_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +#[test] +fn test_module_4() { + let mut instance = create_module_4(); + // We group the calls together + start_module_4(&mut instance); + c226_l570_action_invoke(&mut instance); + c227_l571_action_invoke(&mut instance); + c228_l572_action_invoke(&mut instance); + c229_l573_action_invoke(&mut instance); + c230_l574_action_invoke(&mut instance); + c231_l576_action_invoke(&mut instance); + c232_l577_action_invoke(&mut instance); + c233_l578_action_invoke(&mut instance); + c234_l579_action_invoke(&mut instance); + c235_l580_action_invoke(&mut instance); + c236_l582_action_invoke(&mut instance); + c237_l583_action_invoke(&mut instance); + c238_l584_action_invoke(&mut instance); + c239_l585_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/align.rs b/lib/runtime/tests/spectests/align.rs new file mode 100644 index 000000000..b074cb33a --- /dev/null +++ b/lib/runtime/tests/spectests/align.rs @@ -0,0 +1,2304 @@ +// 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/align.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 3 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + i32.const 0 + i32.load8_s + drop) + (memory (;0;) 0)) + "; + 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 4 + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); +} +fn create_module_2() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + i32.const 0 + i32.load8_u + drop) + (memory (;0;) 0)) + "; + 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_2(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 5 + +#[test] +fn test_module_2() { + let mut instance = create_module_2(); + // We group the calls together + start_module_2(&mut instance); +} +fn create_module_3() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + i32.const 0 + i32.load16_s + drop) + (memory (;0;) 0)) + "; + 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_3(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 6 + +#[test] +fn test_module_3() { + let mut instance = create_module_3(); + // We group the calls together + start_module_3(&mut instance); +} +fn create_module_4() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + i32.const 0 + i32.load16_u + drop) + (memory (;0;) 0)) + "; + 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_4(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 7 + +#[test] +fn test_module_4() { + let mut instance = create_module_4(); + // We group the calls together + start_module_4(&mut instance); +} +fn create_module_5() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + i32.const 0 + i32.load + drop) + (memory (;0;) 0)) + "; + 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_5(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 8 + +#[test] +fn test_module_5() { + let mut instance = create_module_5(); + // We group the calls together + start_module_5(&mut instance); +} +fn create_module_6() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + i32.const 0 + i64.load8_s + drop) + (memory (;0;) 0)) + "; + 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_6(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 9 + +#[test] +fn test_module_6() { + let mut instance = create_module_6(); + // We group the calls together + start_module_6(&mut instance); +} +fn create_module_7() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + i32.const 0 + i64.load8_u + drop) + (memory (;0;) 0)) + "; + 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_7(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 10 + +#[test] +fn test_module_7() { + let mut instance = create_module_7(); + // We group the calls together + start_module_7(&mut instance); +} +fn create_module_8() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + i32.const 0 + i64.load16_s + drop) + (memory (;0;) 0)) + "; + 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_8(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 11 + +#[test] +fn test_module_8() { + let mut instance = create_module_8(); + // We group the calls together + start_module_8(&mut instance); +} +fn create_module_9() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + i32.const 0 + i64.load16_u + drop) + (memory (;0;) 0)) + "; + 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_9(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 12 + +#[test] +fn test_module_9() { + let mut instance = create_module_9(); + // We group the calls together + start_module_9(&mut instance); +} +fn create_module_10() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + i32.const 0 + i64.load32_s + drop) + (memory (;0;) 0)) + "; + 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_10(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 13 + +#[test] +fn test_module_10() { + let mut instance = create_module_10(); + // We group the calls together + start_module_10(&mut instance); +} +fn create_module_11() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + i32.const 0 + i64.load32_u + drop) + (memory (;0;) 0)) + "; + 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_11(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 14 + +#[test] +fn test_module_11() { + let mut instance = create_module_11(); + // We group the calls together + start_module_11(&mut instance); +} +fn create_module_12() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + i32.const 0 + i64.load + drop) + (memory (;0;) 0)) + "; + 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_12(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 15 + +#[test] +fn test_module_12() { + let mut instance = create_module_12(); + // We group the calls together + start_module_12(&mut instance); +} +fn create_module_13() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + i32.const 0 + f32.load + drop) + (memory (;0;) 0)) + "; + 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_13(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 16 + +#[test] +fn test_module_13() { + let mut instance = create_module_13(); + // We group the calls together + start_module_13(&mut instance); +} +fn create_module_14() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + i32.const 0 + f64.load + drop) + (memory (;0;) 0)) + "; + 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_14(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 17 + +#[test] +fn test_module_14() { + let mut instance = create_module_14(); + // We group the calls together + start_module_14(&mut instance); +} +fn create_module_15() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + i32.const 0 + i32.const 1 + i32.store8) + (memory (;0;) 0)) + "; + 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_15(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 18 + +#[test] +fn test_module_15() { + let mut instance = create_module_15(); + // We group the calls together + start_module_15(&mut instance); +} +fn create_module_16() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + i32.const 0 + i32.const 1 + i32.store16) + (memory (;0;) 0)) + "; + 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_16(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 19 + +#[test] +fn test_module_16() { + let mut instance = create_module_16(); + // We group the calls together + start_module_16(&mut instance); +} +fn create_module_17() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + i32.const 0 + i32.const 1 + i32.store) + (memory (;0;) 0)) + "; + 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_17(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 20 + +#[test] +fn test_module_17() { + let mut instance = create_module_17(); + // We group the calls together + start_module_17(&mut instance); +} +fn create_module_18() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + i32.const 0 + i64.const 1 + i64.store8) + (memory (;0;) 0)) + "; + 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_18(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 21 + +#[test] +fn test_module_18() { + let mut instance = create_module_18(); + // We group the calls together + start_module_18(&mut instance); +} +fn create_module_19() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + i32.const 0 + i64.const 1 + i64.store16) + (memory (;0;) 0)) + "; + 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_19(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 22 + +#[test] +fn test_module_19() { + let mut instance = create_module_19(); + // We group the calls together + start_module_19(&mut instance); +} +fn create_module_20() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + i32.const 0 + i64.const 1 + i64.store32) + (memory (;0;) 0)) + "; + 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_20(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 23 + +#[test] +fn test_module_20() { + let mut instance = create_module_20(); + // We group the calls together + start_module_20(&mut instance); +} +fn create_module_21() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + i32.const 0 + i64.const 1 + i64.store) + (memory (;0;) 0)) + "; + 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_21(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 24 + +#[test] +fn test_module_21() { + let mut instance = create_module_21(); + // We group the calls together + start_module_21(&mut instance); +} +fn create_module_22() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + i32.const 0 + f32.const 0x1p+0 (;=1;) + f32.store) + (memory (;0;) 0)) + "; + 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_22(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 25 + +#[test] +fn test_module_22() { + let mut instance = create_module_22(); + // We group the calls together + start_module_22(&mut instance); +} +fn create_module_23() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + i32.const 0 + f64.const 0x1p+0 (;=1;) + f64.store) + (memory (;0;) 0)) + "; + 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_23(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 28 +#[test] +fn c23_l28_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 51, 50, 46, 108, 111, 97, 100, 56, 95, 115, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 34 +#[test] +fn c24_l34_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 51, 50, 46, 108, 111, 97, 100, 56, 95, 115, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 40 +#[test] +fn c25_l40_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 51, 50, 46, 108, 111, 97, 100, 56, 95, 117, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 46 +#[test] +fn c26_l46_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 51, 50, 46, 108, 111, 97, 100, 56, 95, 117, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 52 +#[test] +fn c27_l52_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 51, 50, 46, 108, 111, 97, 100, 49, 54, 95, 115, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 58 +#[test] +fn c28_l58_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 51, 50, 46, 108, 111, 97, 100, 49, 54, 95, 115, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 64 +#[test] +fn c29_l64_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 51, 50, 46, 108, 111, 97, 100, 49, 54, 95, 117, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 70 +#[test] +fn c30_l70_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 51, 50, 46, 108, 111, 97, 100, 49, 54, 95, 117, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 76 +#[test] +fn c31_l76_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 51, 50, 46, 108, 111, 97, 100, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 82 +#[test] +fn c32_l82_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 51, 50, 46, 108, 111, 97, 100, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 88 +#[test] +fn c33_l88_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, 56, 95, 115, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 94 +#[test] +fn c34_l94_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, 56, 95, 115, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 100 +#[test] +fn c35_l100_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, 56, 95, 117, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 106 +#[test] +fn c36_l106_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, 56, 95, 117, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 112 +#[test] +fn c37_l112_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, 49, 54, 95, 115, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 118 +#[test] +fn c38_l118_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, 49, 54, 95, 115, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 124 +#[test] +fn c39_l124_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, 49, 54, 95, 117, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 130 +#[test] +fn c40_l130_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, 49, 54, 95, 117, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 136 +#[test] +fn c41_l136_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, 51, 50, 95, 115, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 142 +#[test] +fn c42_l142_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, 51, 50, 95, 115, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 148 +#[test] +fn c43_l148_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, 51, 50, 95, 117, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 154 +#[test] +fn c44_l154_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, 51, 50, 95, 117, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 160 +#[test] +fn c45_l160_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 166 +#[test] +fn c46_l166_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 54, 52, 46, 108, 111, 97, 100, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 172 +#[test] +fn c47_l172_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 102, 51, 50, 46, 108, 111, 97, 100, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 178 +#[test] +fn c48_l178_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 102, 51, 50, 46, 108, 111, 97, 100, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 184 +#[test] +fn c49_l184_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 102, 54, 52, 46, 108, 111, 97, 100, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 190 +#[test] +fn c50_l190_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 102, 54, 52, 46, 108, 111, 97, 100, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 197 +#[test] +fn c51_l197_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 105, 51, 50, 46, 115, 116, 111, 114, 101, 56, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 203 +#[test] +fn c52_l203_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 105, 51, 50, 46, 115, 116, 111, 114, 101, 56, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 209 +#[test] +fn c53_l209_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 105, 51, 50, 46, 115, 116, 111, 114, 101, 49, 54, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 215 +#[test] +fn c54_l215_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 105, 51, 50, 46, 115, 116, 111, 114, 101, 49, 54, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 221 +#[test] +fn c55_l221_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 105, 51, 50, 46, 115, 116, 111, 114, 101, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 227 +#[test] +fn c56_l227_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 105, 51, 50, 46, 115, 116, 111, 114, 101, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 233 +#[test] +fn c57_l233_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 105, 54, 52, 46, 115, 116, 111, 114, 101, 56, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 239 +#[test] +fn c58_l239_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 105, 54, 52, 46, 115, 116, 111, 114, 101, 56, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 245 +#[test] +fn c59_l245_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 105, 54, 52, 46, 115, 116, 111, 114, 101, 49, 54, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 251 +#[test] +fn c60_l251_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 105, 54, 52, 46, 115, 116, 111, 114, 101, 49, 54, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 257 +#[test] +fn c61_l257_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 105, 54, 52, 46, 115, 116, 111, 114, 101, 51, 50, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 263 +#[test] +fn c62_l263_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 105, 54, 52, 46, 115, 116, 111, 114, 101, 51, 50, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 269 +#[test] +fn c63_l269_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 105, 54, 52, 46, 115, 116, 111, 114, 101, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 275 +#[test] +fn c64_l275_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 105, 54, 52, 46, 115, 116, 111, 114, 101, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 281 +#[test] +fn c65_l281_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 102, 51, 50, 46, 115, 116, 111, 114, 101, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 287 +#[test] +fn c66_l287_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 102, 51, 50, 46, 115, 116, 111, 114, 101, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 293 +#[test] +fn c67_l293_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 102, 54, 52, 46, 115, 116, 111, 114, 101, 32, 97, 108, 105, 103, 110, 61, 48, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 299 +#[test] +fn c68_l299_assert_malformed() { + let wasm_binary = [40, 109, 111, 100, 117, 108, 101, 32, 40, 109, 101, 109, 111, 114, 121, 32, 48, 41, 32, 40, 102, 117, 110, 99, 32, 40, 102, 54, 52, 46, 115, 116, 111, 114, 101, 32, 97, 108, 105, 103, 110, 61, 55, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 306 +#[test] +fn c69_l306_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, 65, 0, 44, 1, 0, 26, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 310 +#[test] +fn c70_l310_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, 65, 0, 45, 1, 0, 26, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 314 +#[test] +fn c71_l314_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, 65, 0, 46, 2, 0, 26, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 318 +#[test] +fn c72_l318_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, 65, 0, 47, 2, 0, 26, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 322 +#[test] +fn c73_l322_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, 65, 0, 40, 3, 0, 26, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 326 +#[test] +fn c74_l326_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, 65, 0, 48, 1, 0, 26, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 330 +#[test] +fn c75_l330_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, 65, 0, 49, 1, 0, 26, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 334 +#[test] +fn c76_l334_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, 65, 0, 50, 2, 0, 26, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 338 +#[test] +fn c77_l338_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, 65, 0, 51, 2, 0, 26, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 342 +#[test] +fn c78_l342_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, 65, 0, 52, 3, 0, 26, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 346 +#[test] +fn c79_l346_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, 65, 0, 53, 3, 0, 26, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 350 +#[test] +fn c80_l350_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, 65, 0, 41, 4, 0, 26, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 354 +#[test] +fn c81_l354_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, 65, 0, 42, 3, 0, 26, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 358 +#[test] +fn c82_l358_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, 65, 0, 43, 4, 0, 26, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 363 +#[test] +fn c83_l363_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, 65, 0, 44, 1, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 367 +#[test] +fn c84_l367_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, 65, 0, 45, 1, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 371 +#[test] +fn c85_l371_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, 65, 0, 46, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 375 +#[test] +fn c86_l375_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, 65, 0, 47, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 379 +#[test] +fn c87_l379_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, 65, 0, 40, 3, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 383 +#[test] +fn c88_l383_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, 65, 0, 48, 1, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 387 +#[test] +fn c89_l387_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, 65, 0, 49, 1, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 391 +#[test] +fn c90_l391_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, 65, 0, 50, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 395 +#[test] +fn c91_l395_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, 65, 0, 51, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 399 +#[test] +fn c92_l399_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, 65, 0, 52, 3, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 403 +#[test] +fn c93_l403_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, 65, 0, 53, 3, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 407 +#[test] +fn c94_l407_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, 65, 0, 41, 4, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 411 +#[test] +fn c95_l411_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, 65, 0, 42, 3, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 415 +#[test] +fn c96_l415_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, 65, 0, 43, 4, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 420 +#[test] +fn c97_l420_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 11, 1, 9, 0, 65, 0, 65, 0, 58, 1, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 424 +#[test] +fn c98_l424_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 11, 1, 9, 0, 65, 0, 65, 0, 59, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 428 +#[test] +fn c99_l428_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 11, 1, 9, 0, 65, 0, 65, 0, 54, 3, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 432 +#[test] +fn c100_l432_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 11, 1, 9, 0, 65, 0, 66, 0, 60, 1, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 436 +#[test] +fn c101_l436_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 11, 1, 9, 0, 65, 0, 66, 0, 61, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 440 +#[test] +fn c102_l440_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 11, 1, 9, 0, 65, 0, 66, 0, 62, 3, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 444 +#[test] +fn c103_l444_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 11, 1, 9, 0, 65, 0, 66, 0, 55, 4, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 448 +#[test] +fn c104_l448_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 14, 1, 12, 0, 65, 0, 67, 0, 0, 0, 0, 56, 3, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 452 +#[test] +fn c105_l452_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 14, 1, 12, 0, 65, 0, 67, 0, 0, 0, 0, 57, 4, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 458 + +#[test] +fn test_module_23() { + let mut instance = create_module_23(); + // We group the calls together + start_module_23(&mut instance); +} +fn create_module_24() -> Box { + let module_str = "(module + (type (;0;) (func (param i32) (result f32))) + (type (;1;) (func (param i32) (result f64))) + (type (;2;) (func (param i32 i32) (result i32))) + (type (;3;) (func (param i32 i32) (result i64))) + (func (;0;) (type 0) (param i32) (result f32) + (local f32 f32) + f32.const 0x1.4p+3 (;=10;) + set_local 1 + block ;; label = @1 + block ;; label = @2 + block ;; label = @3 + block ;; label = @4 + block ;; label = @5 + get_local 0 + br_table 0 (;@5;) 1 (;@4;) 2 (;@3;) 3 (;@2;) 4 (;@1;) + end + i32.const 0 + get_local 1 + f32.store + i32.const 0 + f32.load + set_local 2 + br 3 (;@1;) + end + i32.const 0 + get_local 1 + f32.store align=1 + i32.const 0 + f32.load align=1 + set_local 2 + br 2 (;@1;) + end + i32.const 0 + get_local 1 + f32.store align=2 + i32.const 0 + f32.load align=2 + set_local 2 + br 1 (;@1;) + end + i32.const 0 + get_local 1 + f32.store + i32.const 0 + f32.load + set_local 2 + end + get_local 2) + (func (;1;) (type 1) (param i32) (result f64) + (local f64 f64) + f64.const 0x1.4p+3 (;=10;) + set_local 1 + block ;; label = @1 + block ;; label = @2 + block ;; label = @3 + block ;; label = @4 + block ;; label = @5 + block ;; label = @6 + get_local 0 + br_table 0 (;@6;) 1 (;@5;) 2 (;@4;) 3 (;@3;) 4 (;@2;) 5 (;@1;) + end + i32.const 0 + get_local 1 + f64.store + i32.const 0 + f64.load + set_local 2 + br 4 (;@1;) + end + i32.const 0 + get_local 1 + f64.store align=1 + i32.const 0 + f64.load align=1 + set_local 2 + br 3 (;@1;) + end + i32.const 0 + get_local 1 + f64.store align=2 + i32.const 0 + f64.load align=2 + set_local 2 + br 2 (;@1;) + end + i32.const 0 + get_local 1 + f64.store align=4 + i32.const 0 + f64.load align=4 + set_local 2 + br 1 (;@1;) + end + i32.const 0 + get_local 1 + f64.store + i32.const 0 + f64.load + set_local 2 + end + get_local 2) + (func (;2;) (type 2) (param i32 i32) (result i32) + (local i32 i32) + i32.const 10 + set_local 2 + block ;; label = @1 + block ;; label = @2 + block ;; label = @3 + block ;; label = @4 + block ;; label = @5 + block ;; label = @6 + get_local 0 + br_table 0 (;@6;) 1 (;@5;) 2 (;@4;) 3 (;@3;) 4 (;@2;) 5 (;@1;) + end + get_local 1 + i32.const 0 + i32.eq + if ;; label = @6 + i32.const 0 + get_local 2 + i32.store8 + i32.const 0 + i32.load8_s + set_local 3 + end + get_local 1 + i32.const 1 + i32.eq + if ;; label = @6 + i32.const 0 + get_local 2 + i32.store8 + i32.const 0 + i32.load8_s + set_local 3 + end + br 4 (;@1;) + end + get_local 1 + i32.const 0 + i32.eq + if ;; label = @5 + i32.const 0 + get_local 2 + i32.store8 + i32.const 0 + i32.load8_u + set_local 3 + end + get_local 1 + i32.const 1 + i32.eq + if ;; label = @5 + i32.const 0 + get_local 2 + i32.store8 + i32.const 0 + i32.load8_u + set_local 3 + end + br 3 (;@1;) + end + get_local 1 + i32.const 0 + i32.eq + if ;; label = @4 + i32.const 0 + get_local 2 + i32.store16 + i32.const 0 + i32.load16_s + set_local 3 + end + get_local 1 + i32.const 1 + i32.eq + if ;; label = @4 + i32.const 0 + get_local 2 + i32.store16 align=1 + i32.const 0 + i32.load16_s align=1 + set_local 3 + end + get_local 1 + i32.const 2 + i32.eq + if ;; label = @4 + i32.const 0 + get_local 2 + i32.store16 + i32.const 0 + i32.load16_s + set_local 3 + end + br 2 (;@1;) + end + get_local 1 + i32.const 0 + i32.eq + if ;; label = @3 + i32.const 0 + get_local 2 + i32.store16 + i32.const 0 + i32.load16_u + set_local 3 + end + get_local 1 + i32.const 1 + i32.eq + if ;; label = @3 + i32.const 0 + get_local 2 + i32.store16 align=1 + i32.const 0 + i32.load16_u align=1 + set_local 3 + end + get_local 1 + i32.const 2 + i32.eq + if ;; label = @3 + i32.const 0 + get_local 2 + i32.store16 + i32.const 0 + i32.load16_u + set_local 3 + end + br 1 (;@1;) + end + get_local 1 + i32.const 0 + i32.eq + if ;; label = @2 + i32.const 0 + get_local 2 + i32.store + i32.const 0 + i32.load + set_local 3 + end + get_local 1 + i32.const 1 + i32.eq + if ;; label = @2 + i32.const 0 + get_local 2 + i32.store align=1 + i32.const 0 + i32.load align=1 + set_local 3 + end + get_local 1 + i32.const 2 + i32.eq + if ;; label = @2 + i32.const 0 + get_local 2 + i32.store align=2 + i32.const 0 + i32.load align=2 + set_local 3 + end + get_local 1 + i32.const 4 + i32.eq + if ;; label = @2 + i32.const 0 + get_local 2 + i32.store + i32.const 0 + i32.load + set_local 3 + end + end + get_local 3) + (func (;3;) (type 3) (param i32 i32) (result i64) + (local i64 i64) + i64.const 10 + set_local 2 + block ;; label = @1 + block ;; label = @2 + block ;; label = @3 + block ;; label = @4 + block ;; label = @5 + block ;; label = @6 + block ;; label = @7 + block ;; label = @8 + get_local 0 + br_table 0 (;@8;) 1 (;@7;) 2 (;@6;) 3 (;@5;) 4 (;@4;) 5 (;@3;) 6 (;@2;) 7 (;@1;) + end + get_local 1 + i32.const 0 + i32.eq + if ;; label = @8 + i32.const 0 + get_local 2 + i64.store8 + i32.const 0 + i64.load8_s + set_local 3 + end + get_local 1 + i32.const 1 + i32.eq + if ;; label = @8 + i32.const 0 + get_local 2 + i64.store8 + i32.const 0 + i64.load8_s + set_local 3 + end + br 6 (;@1;) + end + get_local 1 + i32.const 0 + i32.eq + if ;; label = @7 + i32.const 0 + get_local 2 + i64.store8 + i32.const 0 + i64.load8_u + set_local 3 + end + get_local 1 + i32.const 1 + i32.eq + if ;; label = @7 + i32.const 0 + get_local 2 + i64.store8 + i32.const 0 + i64.load8_u + set_local 3 + end + br 5 (;@1;) + end + get_local 1 + i32.const 0 + i32.eq + if ;; label = @6 + i32.const 0 + get_local 2 + i64.store16 + i32.const 0 + i64.load16_s + set_local 3 + end + get_local 1 + i32.const 1 + i32.eq + if ;; label = @6 + i32.const 0 + get_local 2 + i64.store16 align=1 + i32.const 0 + i64.load16_s align=1 + set_local 3 + end + get_local 1 + i32.const 2 + i32.eq + if ;; label = @6 + i32.const 0 + get_local 2 + i64.store16 + i32.const 0 + i64.load16_s + set_local 3 + end + br 4 (;@1;) + end + get_local 1 + i32.const 0 + i32.eq + if ;; label = @5 + i32.const 0 + get_local 2 + i64.store16 + i32.const 0 + i64.load16_u + set_local 3 + end + get_local 1 + i32.const 1 + i32.eq + if ;; label = @5 + i32.const 0 + get_local 2 + i64.store16 align=1 + i32.const 0 + i64.load16_u align=1 + set_local 3 + end + get_local 1 + i32.const 2 + i32.eq + if ;; label = @5 + i32.const 0 + get_local 2 + i64.store16 + i32.const 0 + i64.load16_u + set_local 3 + end + br 3 (;@1;) + end + get_local 1 + i32.const 0 + i32.eq + if ;; label = @4 + i32.const 0 + get_local 2 + i64.store32 + i32.const 0 + i64.load32_s + set_local 3 + end + get_local 1 + i32.const 1 + i32.eq + if ;; label = @4 + i32.const 0 + get_local 2 + i64.store32 align=1 + i32.const 0 + i64.load32_s align=1 + set_local 3 + end + get_local 1 + i32.const 2 + i32.eq + if ;; label = @4 + i32.const 0 + get_local 2 + i64.store32 align=2 + i32.const 0 + i64.load32_s align=2 + set_local 3 + end + get_local 1 + i32.const 4 + i32.eq + if ;; label = @4 + i32.const 0 + get_local 2 + i64.store32 + i32.const 0 + i64.load32_s + set_local 3 + end + br 2 (;@1;) + end + get_local 1 + i32.const 0 + i32.eq + if ;; label = @3 + i32.const 0 + get_local 2 + i64.store32 + i32.const 0 + i64.load32_u + set_local 3 + end + get_local 1 + i32.const 1 + i32.eq + if ;; label = @3 + i32.const 0 + get_local 2 + i64.store32 align=1 + i32.const 0 + i64.load32_u align=1 + set_local 3 + end + get_local 1 + i32.const 2 + i32.eq + if ;; label = @3 + i32.const 0 + get_local 2 + i64.store32 align=2 + i32.const 0 + i64.load32_u align=2 + set_local 3 + end + get_local 1 + i32.const 4 + i32.eq + if ;; label = @3 + i32.const 0 + get_local 2 + i64.store32 + i32.const 0 + i64.load32_u + set_local 3 + end + br 1 (;@1;) + end + get_local 1 + i32.const 0 + i32.eq + if ;; label = @2 + i32.const 0 + get_local 2 + i64.store + i32.const 0 + i64.load + set_local 3 + end + get_local 1 + i32.const 1 + i32.eq + if ;; label = @2 + i32.const 0 + get_local 2 + i64.store align=1 + i32.const 0 + i64.load align=1 + set_local 3 + end + get_local 1 + i32.const 2 + i32.eq + if ;; label = @2 + i32.const 0 + get_local 2 + i64.store align=2 + i32.const 0 + i64.load align=2 + set_local 3 + end + get_local 1 + i32.const 4 + i32.eq + if ;; label = @2 + i32.const 0 + get_local 2 + i64.store align=4 + i32.const 0 + i64.load align=4 + set_local 3 + end + get_local 1 + i32.const 8 + i32.eq + if ;; label = @2 + i32.const 0 + get_local 2 + i64.store + i32.const 0 + i64.load + set_local 3 + end + end + get_local 3) + (memory (;0;) 1) + (export \"f32_align_switch\" (func 0)) + (export \"f64_align_switch\" (func 1)) + (export \"i32_align_switch\" (func 2)) + (export \"i64_align_switch\" (func 3))) + "; + 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_24(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 802 +fn c107_l802_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c107_l802_action_invoke"); + let result = instance.call("f32_align_switch", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((10.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 803 +fn c108_l803_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c108_l803_action_invoke"); + let result = instance.call("f32_align_switch", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((10.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 804 +fn c109_l804_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c109_l804_action_invoke"); + let result = instance.call("f32_align_switch", &[Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((10.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 805 +fn c110_l805_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c110_l805_action_invoke"); + let result = instance.call("f32_align_switch", &[Value::I32(3 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((10.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 807 +fn c111_l807_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c111_l807_action_invoke"); + let result = instance.call("f64_align_switch", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((10.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 808 +fn c112_l808_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c112_l808_action_invoke"); + let result = instance.call("f64_align_switch", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((10.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 809 +fn c113_l809_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c113_l809_action_invoke"); + let result = instance.call("f64_align_switch", &[Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((10.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 810 +fn c114_l810_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c114_l810_action_invoke"); + let result = instance.call("f64_align_switch", &[Value::I32(3 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((10.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 811 +fn c115_l811_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c115_l811_action_invoke"); + let result = instance.call("f64_align_switch", &[Value::I32(4 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((10.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 813 +fn c116_l813_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c116_l813_action_invoke"); + let result = instance.call("i32_align_switch", &[Value::I32(0 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); + result.map(|_| ()) +} + +// Line 814 +fn c117_l814_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c117_l814_action_invoke"); + let result = instance.call("i32_align_switch", &[Value::I32(0 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); + result.map(|_| ()) +} + +// Line 815 +fn c118_l815_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c118_l815_action_invoke"); + let result = instance.call("i32_align_switch", &[Value::I32(1 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); + result.map(|_| ()) +} + +// Line 816 +fn c119_l816_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c119_l816_action_invoke"); + let result = instance.call("i32_align_switch", &[Value::I32(1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); + result.map(|_| ()) +} + +// Line 817 +fn c120_l817_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c120_l817_action_invoke"); + let result = instance.call("i32_align_switch", &[Value::I32(2 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); + result.map(|_| ()) +} + +// Line 818 +fn c121_l818_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c121_l818_action_invoke"); + let result = instance.call("i32_align_switch", &[Value::I32(2 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); + result.map(|_| ()) +} + +// Line 819 +fn c122_l819_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c122_l819_action_invoke"); + let result = instance.call("i32_align_switch", &[Value::I32(2 as i32), Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); + result.map(|_| ()) +} + +// Line 820 +fn c123_l820_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c123_l820_action_invoke"); + let result = instance.call("i32_align_switch", &[Value::I32(3 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); + result.map(|_| ()) +} + +// Line 821 +fn c124_l821_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c124_l821_action_invoke"); + let result = instance.call("i32_align_switch", &[Value::I32(3 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); + result.map(|_| ()) +} + +// Line 822 +fn c125_l822_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c125_l822_action_invoke"); + let result = instance.call("i32_align_switch", &[Value::I32(3 as i32), Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); + result.map(|_| ()) +} + +// Line 823 +fn c126_l823_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c126_l823_action_invoke"); + let result = instance.call("i32_align_switch", &[Value::I32(4 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); + result.map(|_| ()) +} + +// Line 824 +fn c127_l824_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c127_l824_action_invoke"); + let result = instance.call("i32_align_switch", &[Value::I32(4 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); + result.map(|_| ()) +} + +// Line 825 +fn c128_l825_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c128_l825_action_invoke"); + let result = instance.call("i32_align_switch", &[Value::I32(4 as i32), Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); + result.map(|_| ()) +} + +// Line 826 +fn c129_l826_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c129_l826_action_invoke"); + let result = instance.call("i32_align_switch", &[Value::I32(4 as i32), Value::I32(4 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); + result.map(|_| ()) +} + +// Line 828 +fn c130_l828_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c130_l828_action_invoke"); + let result = instance.call("i64_align_switch", &[Value::I32(0 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); + result.map(|_| ()) +} + +// Line 829 +fn c131_l829_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c131_l829_action_invoke"); + let result = instance.call("i64_align_switch", &[Value::I32(0 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); + result.map(|_| ()) +} + +// Line 830 +fn c132_l830_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c132_l830_action_invoke"); + let result = instance.call("i64_align_switch", &[Value::I32(1 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); + result.map(|_| ()) +} + +// Line 831 +fn c133_l831_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c133_l831_action_invoke"); + let result = instance.call("i64_align_switch", &[Value::I32(1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); + result.map(|_| ()) +} + +// Line 832 +fn c134_l832_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c134_l832_action_invoke"); + let result = instance.call("i64_align_switch", &[Value::I32(2 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); + result.map(|_| ()) +} + +// Line 833 +fn c135_l833_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c135_l833_action_invoke"); + let result = instance.call("i64_align_switch", &[Value::I32(2 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); + result.map(|_| ()) +} + +// Line 834 +fn c136_l834_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c136_l834_action_invoke"); + let result = instance.call("i64_align_switch", &[Value::I32(2 as i32), Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); + result.map(|_| ()) +} + +// Line 835 +fn c137_l835_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c137_l835_action_invoke"); + let result = instance.call("i64_align_switch", &[Value::I32(3 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); + result.map(|_| ()) +} + +// Line 836 +fn c138_l836_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c138_l836_action_invoke"); + let result = instance.call("i64_align_switch", &[Value::I32(3 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); + result.map(|_| ()) +} + +// Line 837 +fn c139_l837_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c139_l837_action_invoke"); + let result = instance.call("i64_align_switch", &[Value::I32(3 as i32), Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); + result.map(|_| ()) +} + +// Line 838 +fn c140_l838_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c140_l838_action_invoke"); + let result = instance.call("i64_align_switch", &[Value::I32(4 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); + result.map(|_| ()) +} + +// Line 839 +fn c141_l839_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c141_l839_action_invoke"); + let result = instance.call("i64_align_switch", &[Value::I32(4 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); + result.map(|_| ()) +} + +// Line 840 +fn c142_l840_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c142_l840_action_invoke"); + let result = instance.call("i64_align_switch", &[Value::I32(4 as i32), Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); + result.map(|_| ()) +} + +// Line 841 +fn c143_l841_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c143_l841_action_invoke"); + let result = instance.call("i64_align_switch", &[Value::I32(4 as i32), Value::I32(4 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); + result.map(|_| ()) +} + +// Line 842 +fn c144_l842_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c144_l842_action_invoke"); + let result = instance.call("i64_align_switch", &[Value::I32(5 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); + result.map(|_| ()) +} + +// Line 843 +fn c145_l843_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c145_l843_action_invoke"); + let result = instance.call("i64_align_switch", &[Value::I32(5 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); + result.map(|_| ()) +} + +// Line 844 +fn c146_l844_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c146_l844_action_invoke"); + let result = instance.call("i64_align_switch", &[Value::I32(5 as i32), Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); + result.map(|_| ()) +} + +// Line 845 +fn c147_l845_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c147_l845_action_invoke"); + let result = instance.call("i64_align_switch", &[Value::I32(5 as i32), Value::I32(4 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); + result.map(|_| ()) +} + +// Line 846 +fn c148_l846_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c148_l846_action_invoke"); + let result = instance.call("i64_align_switch", &[Value::I32(6 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); + result.map(|_| ()) +} + +// Line 847 +fn c149_l847_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c149_l847_action_invoke"); + let result = instance.call("i64_align_switch", &[Value::I32(6 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); + result.map(|_| ()) +} + +// Line 848 +fn c150_l848_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c150_l848_action_invoke"); + let result = instance.call("i64_align_switch", &[Value::I32(6 as i32), Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); + result.map(|_| ()) +} + +// Line 849 +fn c151_l849_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c151_l849_action_invoke"); + let result = instance.call("i64_align_switch", &[Value::I32(6 as i32), Value::I32(4 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); + result.map(|_| ()) +} + +// Line 850 +fn c152_l850_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c152_l850_action_invoke"); + let result = instance.call("i64_align_switch", &[Value::I32(6 as i32), Value::I32(8 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); + result.map(|_| ()) +} + +#[test] +fn test_module_24() { + let mut instance = create_module_24(); + // We group the calls together + start_module_24(&mut instance); + c107_l802_action_invoke(&mut instance); + c108_l803_action_invoke(&mut instance); + c109_l804_action_invoke(&mut instance); + c110_l805_action_invoke(&mut instance); + c111_l807_action_invoke(&mut instance); + c112_l808_action_invoke(&mut instance); + c113_l809_action_invoke(&mut instance); + c114_l810_action_invoke(&mut instance); + c115_l811_action_invoke(&mut instance); + c116_l813_action_invoke(&mut instance); + c117_l814_action_invoke(&mut instance); + c118_l815_action_invoke(&mut instance); + c119_l816_action_invoke(&mut instance); + c120_l817_action_invoke(&mut instance); + c121_l818_action_invoke(&mut instance); + c122_l819_action_invoke(&mut instance); + c123_l820_action_invoke(&mut instance); + c124_l821_action_invoke(&mut instance); + c125_l822_action_invoke(&mut instance); + c126_l823_action_invoke(&mut instance); + c127_l824_action_invoke(&mut instance); + c128_l825_action_invoke(&mut instance); + c129_l826_action_invoke(&mut instance); + c130_l828_action_invoke(&mut instance); + c131_l829_action_invoke(&mut instance); + c132_l830_action_invoke(&mut instance); + c133_l831_action_invoke(&mut instance); + c134_l832_action_invoke(&mut instance); + c135_l833_action_invoke(&mut instance); + c136_l834_action_invoke(&mut instance); + c137_l835_action_invoke(&mut instance); + c138_l836_action_invoke(&mut instance); + c139_l837_action_invoke(&mut instance); + c140_l838_action_invoke(&mut instance); + c141_l839_action_invoke(&mut instance); + c142_l840_action_invoke(&mut instance); + c143_l841_action_invoke(&mut instance); + c144_l842_action_invoke(&mut instance); + c145_l843_action_invoke(&mut instance); + c146_l844_action_invoke(&mut instance); + c147_l845_action_invoke(&mut instance); + c148_l846_action_invoke(&mut instance); + c149_l847_action_invoke(&mut instance); + c150_l848_action_invoke(&mut instance); + c151_l849_action_invoke(&mut instance); + c152_l850_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/binary.rs b/lib/runtime/tests/spectests/binary.rs new file mode 100644 index 000000000..a2909dae9 --- /dev/null +++ b/lib/runtime/tests/spectests/binary.rs @@ -0,0 +1,841 @@ +// 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/binary.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 1 +fn create_module_1() -> Box { + let module_str = "(module) + "; + 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 2 + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); +} +fn create_module_2() -> Box { + let module_str = "(module) + "; + 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_2(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 3 + +#[test] +fn test_module_2() { + let mut instance = create_module_2(); + // We group the calls together + start_module_2(&mut instance); +} +fn create_module_3() -> Box { + let module_str = "(module) + "; + 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_3(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 4 + +#[test] +fn test_module_3() { + let mut instance = create_module_3(); + // We group the calls together + start_module_3(&mut instance); +} +fn create_module_4() -> Box { + let module_str = "(module) + "; + 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_4(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 6 +#[test] +fn c4_l6_assert_malformed() { + let wasm_binary = []; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 7 +#[test] +fn c5_l7_assert_malformed() { + let wasm_binary = [1]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 8 +#[test] +fn c6_l8_assert_malformed() { + let wasm_binary = [0, 97, 115]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 9 +#[test] +fn c7_l9_assert_malformed() { + let wasm_binary = [97, 115, 109, 0]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 10 +#[test] +fn c8_l10_assert_malformed() { + let wasm_binary = [109, 115, 97, 0]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 11 +#[test] +fn c9_l11_assert_malformed() { + let wasm_binary = [109, 115, 97, 0, 1, 0, 0, 0]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 12 +#[test] +fn c10_l12_assert_malformed() { + let wasm_binary = [109, 115, 97, 0, 0, 0, 0, 1]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 13 +#[test] +fn c11_l13_assert_malformed() { + let wasm_binary = [97, 115, 109, 1, 0, 0, 0, 0]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 14 +#[test] +fn c12_l14_assert_malformed() { + let wasm_binary = [119, 97, 115, 109, 1, 0, 0, 0]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 15 +#[test] +fn c13_l15_assert_malformed() { + let wasm_binary = [127, 97, 115, 109, 1, 0, 0, 0]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 16 +#[test] +fn c14_l16_assert_malformed() { + let wasm_binary = [128, 97, 115, 109, 1, 0, 0, 0]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 17 +#[test] +fn c15_l17_assert_malformed() { + let wasm_binary = [130, 97, 115, 109, 1, 0, 0, 0]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 18 +#[test] +fn c16_l18_assert_malformed() { + let wasm_binary = [255, 97, 115, 109, 1, 0, 0, 0]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 21 +#[test] +fn c17_l21_assert_malformed() { + let wasm_binary = [0, 0, 0, 1, 109, 115, 97, 0]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 24 +#[test] +fn c18_l24_assert_malformed() { + let wasm_binary = [97, 0, 109, 115, 0, 1, 0, 0]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 25 +#[test] +fn c19_l25_assert_malformed() { + let wasm_binary = [115, 109, 0, 97, 0, 0, 1, 0]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 28 +#[test] +fn c20_l28_assert_malformed() { + let wasm_binary = [0, 65, 83, 77, 1, 0, 0, 0]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 31 +#[test] +fn c21_l31_assert_malformed() { + let wasm_binary = [0, 129, 162, 148, 1, 0, 0, 0]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 34 +#[test] +fn c22_l34_assert_malformed() { + let wasm_binary = [239, 187, 191, 0, 97, 115, 109, 1, 0, 0, 0]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 36 +#[test] +fn c23_l36_assert_malformed() { + let wasm_binary = [0, 97, 115, 109]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 37 +#[test] +fn c24_l37_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 38 +#[test] +fn c25_l38_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 39 +#[test] +fn c26_l39_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 0, 0, 0, 0]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 40 +#[test] +fn c27_l40_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 13, 0, 0, 0]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 41 +#[test] +fn c28_l41_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 14, 0, 0, 0]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 42 +#[test] +fn c29_l42_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 0, 1, 0, 0]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 43 +#[test] +fn c30_l43_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 0, 0, 1, 0]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 44 +#[test] +fn c31_l44_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 0, 0, 0, 1]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 47 + +#[test] +fn test_module_4() { + let mut instance = create_module_4(); + // We group the calls together + start_module_4(&mut instance); +} +fn create_module_5() -> Box { + let module_str = "(module + (memory (;0;) 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_5(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 52 + +#[test] +fn test_module_5() { + let mut instance = create_module_5(); + // We group the calls together + start_module_5(&mut instance); +} +fn create_module_6() -> Box { + let module_str = "(module + (memory (;0;) 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_6(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 59 + +#[test] +fn test_module_6() { + let mut instance = create_module_6(); + // We group the calls together + start_module_6(&mut instance); +} +fn create_module_7() -> Box { + let module_str = "(module + (global (;0;) i32 (i32.const 0))) + "; + 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_7(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 66 + +#[test] +fn test_module_7() { + let mut instance = create_module_7(); + // We group the calls together + start_module_7(&mut instance); +} +fn create_module_8() -> Box { + let module_str = "(module + (global (;0;) i32 (i32.const -1))) + "; + 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_8(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 73 + +#[test] +fn test_module_8() { + let mut instance = create_module_8(); + // We group the calls together + start_module_8(&mut instance); +} +fn create_module_9() -> Box { + let module_str = "(module + (global (;0;) i32 (i32.const 0))) + "; + 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_9(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 80 + +#[test] +fn test_module_9() { + let mut instance = create_module_9(); + // We group the calls together + start_module_9(&mut instance); +} +fn create_module_10() -> Box { + let module_str = "(module + (global (;0;) i32 (i32.const -1))) + "; + 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_10(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 88 + +#[test] +fn test_module_10() { + let mut instance = create_module_10(); + // We group the calls together + start_module_10(&mut instance); +} +fn create_module_11() -> Box { + let module_str = "(module + (global (;0;) i64 (i64.const 0))) + "; + 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_11(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 95 + +#[test] +fn test_module_11() { + let mut instance = create_module_11(); + // We group the calls together + start_module_11(&mut instance); +} +fn create_module_12() -> Box { + let module_str = "(module + (global (;0;) i64 (i64.const -1))) + "; + 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_12(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 102 + +#[test] +fn test_module_12() { + let mut instance = create_module_12(); + // We group the calls together + start_module_12(&mut instance); +} +fn create_module_13() -> Box { + let module_str = "(module + (global (;0;) i64 (i64.const 0))) + "; + 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_13(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 109 + +#[test] +fn test_module_13() { + let mut instance = create_module_13(); + // We group the calls together + start_module_13(&mut instance); +} +fn create_module_14() -> Box { + let module_str = "(module + (global (;0;) i64 (i64.const -1))) + "; + 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_14(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 118 + +#[test] +fn test_module_14() { + let mut instance = create_module_14(); + // We group the calls together + start_module_14(&mut instance); +} +fn create_module_15() -> Box { + let module_str = "(module + (memory (;0;) 0) + (data (;0;) (i32.const 0) \"\")) + "; + 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_15(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 128 + +#[test] +fn test_module_15() { + let mut instance = create_module_15(); + // We group the calls together + start_module_15(&mut instance); +} +fn create_module_16() -> Box { + let module_str = "(module + (table (;0;) 0 anyfunc) + (elem (;0;) (i32.const 0))) + "; + 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_16(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 139 +#[test] +fn c44_l139_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 8, 1, 0, 130, 128, 128, 128, 128, 0]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 149 +#[test] +fn c45_l149_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 11, 1, 127, 0, 65, 128, 128, 128, 128, 128, 0, 11]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 159 +#[test] +fn c46_l159_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 11, 1, 127, 0, 65, 255, 255, 255, 255, 255, 127, 11]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 170 +#[test] +fn c47_l170_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 16, 1, 126, 0, 66, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 0, 11]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 180 +#[test] +fn c48_l180_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 16, 1, 126, 0, 66, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 127, 11]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 192 +#[test] +fn c49_l192_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 7, 1, 0, 130, 128, 128, 128, 112]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 200 +#[test] +fn c50_l200_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 7, 1, 0, 130, 128, 128, 128, 64]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 210 +#[test] +fn c51_l210_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 10, 1, 127, 0, 65, 128, 128, 128, 128, 112, 11]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 220 +#[test] +fn c52_l220_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 10, 1, 127, 0, 65, 255, 255, 255, 255, 15, 11]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 230 +#[test] +fn c53_l230_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 10, 1, 127, 0, 65, 128, 128, 128, 128, 31, 11]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 240 +#[test] +fn c54_l240_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 10, 1, 127, 0, 65, 255, 255, 255, 255, 79, 11]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 251 +#[test] +fn c55_l251_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 15, 1, 126, 0, 66, 128, 128, 128, 128, 128, 128, 128, 128, 128, 126, 11]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 261 +#[test] +fn c56_l261_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 15, 1, 126, 0, 66, 255, 255, 255, 255, 255, 255, 255, 255, 255, 1, 11]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 271 +#[test] +fn c57_l271_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 15, 1, 126, 0, 66, 128, 128, 128, 128, 128, 128, 128, 128, 128, 2, 11]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 281 +#[test] +fn c58_l281_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 15, 1, 126, 0, 66, 255, 255, 255, 255, 255, 255, 255, 255, 255, 65, 11]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 293 +#[test] +fn c59_l293_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 10, 9, 1, 7, 0, 65, 0, 17, 0, 1, 11]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 312 +#[test] +fn c60_l312_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 10, 10, 1, 7, 0, 65, 0, 17, 0, 128, 0, 11]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 331 +#[test] +fn c61_l331_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 10, 11, 1, 8, 0, 65, 0, 17, 0, 128, 128, 0, 11]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 349 +#[test] +fn c62_l349_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 10, 12, 1, 9, 0, 65, 0, 17, 0, 128, 128, 128, 0, 11]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 367 +#[test] +fn c63_l367_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 10, 13, 1, 10, 0, 65, 0, 17, 0, 128, 128, 128, 128, 0, 11]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 386 +#[test] +fn c64_l386_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, 65, 0, 64, 1, 26, 11]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 406 +#[test] +fn c65_l406_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, 65, 0, 64, 128, 0, 26, 11]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 426 +#[test] +fn c66_l426_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 11, 1, 9, 0, 65, 0, 64, 128, 128, 0, 26, 11]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 445 +#[test] +fn c67_l445_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 12, 1, 10, 0, 65, 0, 64, 128, 128, 128, 0, 26, 11]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 464 +#[test] +fn c68_l464_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 13, 1, 11, 0, 65, 0, 64, 128, 128, 128, 128, 0, 26, 11]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 484 +#[test] +fn c69_l484_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 7, 1, 5, 0, 63, 1, 26, 11]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 503 +#[test] +fn c70_l503_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 8, 1, 6, 0, 63, 128, 0, 26, 11]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 522 +#[test] +fn c71_l522_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 9, 1, 7, 0, 63, 128, 128, 0, 26, 11]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 540 +#[test] +fn c72_l540_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 10, 1, 8, 0, 63, 128, 128, 128, 0, 26, 11]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 558 +#[test] +fn c73_l558_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 10, 11, 1, 9, 0, 63, 128, 128, 128, 128, 0, 26, 11]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 577 +#[test] +fn c74_l577_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 2, 255, 255, 255, 255, 15, 127, 2, 126, 11]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +#[test] +fn test_module_16() { + let mut instance = create_module_16(); + // We group the calls together + start_module_16(&mut instance); +} diff --git a/lib/runtime/tests/spectests/block.rs b/lib/runtime/tests/spectests/block.rs new file mode 100644 index 000000000..9551e9572 --- /dev/null +++ b/lib/runtime/tests/spectests/block.rs @@ -0,0 +1,1930 @@ +// 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/block.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 3 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func (param i32 i32) (result i32))) + (type (;1;) (func)) + (type (;2;) (func (result i32))) + (type (;3;) (func (param i32) (result i32))) + (func (;0;) (type 1)) + (func (;1;) (type 1) + block ;; label = @1 + end + block ;; label = @1 + end) + (func (;2;) (type 2) (result i32) + block ;; label = @1 + nop + end + block (result i32) ;; label = @1 + i32.const 7 + end) + (func (;3;) (type 2) (result i32) + block ;; label = @1 + call 0 + call 0 + call 0 + call 0 + end + block (result i32) ;; label = @1 + call 0 + call 0 + call 0 + i32.const 8 + end) + (func (;4;) (type 2) (result i32) + block (result i32) ;; label = @1 + block ;; label = @2 + call 0 + block ;; label = @3 + end + nop + end + block (result i32) ;; label = @2 + call 0 + i32.const 9 + end + end) + (func (;5;) (type 2) (result i32) + block (result i32) ;; label = @1 + block (result i32) ;; label = @2 + block (result i32) ;; label = @3 + block (result i32) ;; label = @4 + block (result i32) ;; label = @5 + block (result i32) ;; label = @6 + block (result i32) ;; label = @7 + block (result i32) ;; label = @8 + block (result i32) ;; label = @9 + block (result i32) ;; label = @10 + block (result i32) ;; label = @11 + block (result i32) ;; label = @12 + block (result i32) ;; label = @13 + block (result i32) ;; label = @14 + block (result i32) ;; label = @15 + block (result i32) ;; label = @16 + block (result i32) ;; label = @17 + block (result i32) ;; label = @18 + block (result i32) ;; label = @19 + block (result i32) ;; label = @20 + block (result i32) ;; label = @21 + block (result i32) ;; label = @22 + block (result i32) ;; label = @23 + block (result i32) ;; label = @24 + block (result i32) ;; label = @25 + block (result i32) ;; label = @26 + block (result i32) ;; label = @27 + block (result i32) ;; label = @28 + block (result i32) ;; label = @29 + block (result i32) ;; label = @30 + block (result i32) ;; label = @31 + block (result i32) ;; label = @32 + block (result i32) ;; label = @33 + block (result i32) ;; label = @34 + block (result i32) ;; label = @35 + block (result i32) ;; label = @36 + block (result i32) ;; label = @37 + block (result i32) ;; label = @38 + call 0 + i32.const 150 + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end) + (func (;6;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + end + i32.const 2 + i32.const 3 + select) + (func (;7;) (type 2) (result i32) + i32.const 2 + block (result i32) ;; label = @1 + i32.const 1 + end + i32.const 3 + select) + (func (;8;) (type 2) (result i32) + i32.const 2 + i32.const 3 + block (result i32) ;; label = @1 + i32.const 1 + end + select) + (func (;9;) (type 2) (result i32) + loop (result i32) ;; label = @1 + block (result i32) ;; label = @2 + i32.const 1 + end + call 0 + call 0 + end) + (func (;10;) (type 2) (result i32) + loop (result i32) ;; label = @1 + call 0 + block (result i32) ;; label = @2 + i32.const 1 + end + call 0 + end) + (func (;11;) (type 2) (result i32) + loop (result i32) ;; label = @1 + call 0 + call 0 + block (result i32) ;; label = @2 + i32.const 1 + end + end) + (func (;12;) (type 1) + block (result i32) ;; label = @1 + i32.const 1 + end + if ;; label = @1 + call 0 + end) + (func (;13;) (type 2) (result i32) + i32.const 1 + if (result i32) ;; label = @1 + block (result i32) ;; label = @2 + i32.const 1 + end + else + i32.const 2 + end) + (func (;14;) (type 2) (result i32) + i32.const 1 + if (result i32) ;; label = @1 + i32.const 2 + else + block (result i32) ;; label = @2 + i32.const 1 + end + end) + (func (;15;) (type 2) (result i32) + block (result i32) ;; label = @1 + block (result i32) ;; label = @2 + i32.const 1 + end + i32.const 2 + br_if 0 (;@1;) + end) + (func (;16;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 2 + block (result i32) ;; label = @2 + i32.const 1 + end + br_if 0 (;@1;) + end) + (func (;17;) (type 2) (result i32) + block (result i32) ;; label = @1 + block (result i32) ;; label = @2 + i32.const 1 + end + i32.const 2 + br_table 0 (;@1;) 0 (;@1;) + end) + (func (;18;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 2 + block (result i32) ;; label = @2 + i32.const 1 + end + br_table 0 (;@1;) 0 (;@1;) + end) + (func (;19;) (type 0) (param i32 i32) (result i32) + get_local 0) + (func (;20;) (type 2) (result i32) + block (result i32) ;; label = @1 + block (result i32) ;; label = @2 + i32.const 1 + end + i32.const 2 + i32.const 0 + call_indirect (type 0) + end) + (func (;21;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 2 + block (result i32) ;; label = @2 + i32.const 1 + end + i32.const 0 + call_indirect (type 0) + end) + (func (;22;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + i32.const 2 + block (result i32) ;; label = @2 + i32.const 0 + end + call_indirect (type 0) + end) + (func (;23;) (type 1) + block (result i32) ;; label = @1 + i32.const 1 + end + i32.const 1 + i32.store) + (func (;24;) (type 1) + i32.const 10 + block (result i32) ;; label = @1 + i32.const 1 + end + i32.store) + (func (;25;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + end + memory.grow) + (func (;26;) (type 3) (param i32) (result i32) + get_local 0) + (func (;27;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + end + call 26) + (func (;28;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + end + return) + (func (;29;) (type 1) + block (result i32) ;; label = @1 + i32.const 1 + end + drop) + (func (;30;) (type 2) (result i32) + block (result i32) ;; label = @1 + block (result i32) ;; label = @2 + i32.const 1 + end + br 0 (;@1;) + end) + (func (;31;) (type 2) (result i32) + (local i32) + block (result i32) ;; label = @1 + i32.const 1 + end + set_local 0 + get_local 0) + (func (;32;) (type 2) (result i32) + (local i32) + block (result i32) ;; label = @1 + i32.const 1 + end + tee_local 0) + (func (;33;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + end + set_global 0 + get_global 0) + (func (;34;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + end + i32.load) + (func (;35;) (type 2) (result i32) + block (result i32) ;; label = @1 + call 0 + i32.const 13 + end + i32.ctz) + (func (;36;) (type 2) (result i32) + block (result i32) ;; label = @1 + call 0 + i32.const 3 + end + block (result i32) ;; label = @1 + call 0 + i32.const 4 + end + i32.mul) + (func (;37;) (type 2) (result i32) + block (result i32) ;; label = @1 + call 0 + i32.const 13 + end + i32.eqz) + (func (;38;) (type 2) (result i32) + block (result f32) ;; label = @1 + call 0 + f32.const 0x1.8p+1 (;=3;) + end + block (result f32) ;; label = @1 + call 0 + f32.const 0x1.8p+1 (;=3;) + end + f32.gt) + (func (;39;) (type 2) (result i32) + block ;; label = @1 + br 0 (;@1;) + unreachable + end + block ;; label = @1 + i32.const 1 + br_if 0 (;@1;) + unreachable + end + block ;; label = @1 + i32.const 0 + br_table 0 (;@1;) + unreachable + end + block ;; label = @1 + i32.const 1 + br_table 0 (;@1;) 0 (;@1;) 0 (;@1;) + unreachable + end + i32.const 19) + (func (;40;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 18 + br 0 (;@1;) + i32.const 19 + end) + (func (;41;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 18 + br 0 (;@1;) + i32.const 19 + br 0 (;@1;) + i32.const 20 + i32.const 0 + br_if 0 (;@1;) + drop + i32.const 20 + i32.const 1 + br_if 0 (;@1;) + drop + i32.const 21 + br 0 (;@1;) + i32.const 22 + i32.const 4 + br_table 0 (;@1;) + i32.const 23 + i32.const 1 + br_table 0 (;@1;) 0 (;@1;) 0 (;@1;) + i32.const 21 + end) + (func (;42;) (type 2) (result i32) + (local i32) + i32.const 0 + set_local 0 + get_local 0 + block (result i32) ;; label = @1 + block (result i32) ;; label = @2 + i32.const 1 + br 1 (;@1;) + end + end + i32.add + set_local 0 + get_local 0 + block (result i32) ;; label = @1 + block ;; label = @2 + br 0 (;@2;) + end + i32.const 2 + end + i32.add + set_local 0 + get_local 0 + block (result i32) ;; label = @1 + i32.const 4 + br 0 (;@1;) + i32.ctz + end + i32.add + set_local 0 + get_local 0 + block (result i32) ;; label = @1 + block (result i32) ;; label = @2 + i32.const 8 + br 1 (;@1;) + end + i32.ctz + end + i32.add + set_local 0 + get_local 0) + (func (;43;) (type 2) (result i32) + (local i32) + block ;; label = @1 + i32.const 1 + set_local 0 + get_local 0 + i32.const 3 + i32.mul + set_local 0 + get_local 0 + i32.const 5 + i32.sub + set_local 0 + get_local 0 + i32.const 7 + i32.mul + set_local 0 + br 0 (;@1;) + get_local 0 + i32.const 100 + i32.mul + set_local 0 + end + get_local 0 + i32.const -14 + i32.eq) + (table (;0;) 1 1 anyfunc) + (memory (;0;) 1) + (global (;0;) (mut i32) (i32.const 10)) + (export \"empty\" (func 1)) + (export \"singular\" (func 2)) + (export \"multi\" (func 3)) + (export \"nested\" (func 4)) + (export \"deep\" (func 5)) + (export \"as-select-first\" (func 6)) + (export \"as-select-mid\" (func 7)) + (export \"as-select-last\" (func 8)) + (export \"as-loop-first\" (func 9)) + (export \"as-loop-mid\" (func 10)) + (export \"as-loop-last\" (func 11)) + (export \"as-if-condition\" (func 12)) + (export \"as-if-then\" (func 13)) + (export \"as-if-else\" (func 14)) + (export \"as-br_if-first\" (func 15)) + (export \"as-br_if-last\" (func 16)) + (export \"as-br_table-first\" (func 17)) + (export \"as-br_table-last\" (func 18)) + (export \"as-call_indirect-first\" (func 20)) + (export \"as-call_indirect-mid\" (func 21)) + (export \"as-call_indirect-last\" (func 22)) + (export \"as-store-first\" (func 23)) + (export \"as-store-last\" (func 24)) + (export \"as-memory.grow-value\" (func 25)) + (export \"as-call-value\" (func 27)) + (export \"as-return-value\" (func 28)) + (export \"as-drop-operand\" (func 29)) + (export \"as-br-value\" (func 30)) + (export \"as-set_local-value\" (func 31)) + (export \"as-tee_local-value\" (func 32)) + (export \"as-set_global-value\" (func 33)) + (export \"as-load-operand\" (func 34)) + (export \"as-unary-operand\" (func 35)) + (export \"as-binary-operand\" (func 36)) + (export \"as-test-operand\" (func 37)) + (export \"as-compare-operand\" (func 38)) + (export \"break-bare\" (func 39)) + (export \"break-value\" (func 40)) + (export \"break-repeated\" (func 41)) + (export \"break-inner\" (func 42)) + (export \"effects\" (func 43)) + (elem (;0;) (i32.const 0) 19)) + "; + 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 252 +fn c1_l252_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l252_action_invoke"); + let result = instance.call("empty", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 253 +fn c2_l253_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l253_action_invoke"); + let result = instance.call("singular", &[]); + assert_eq!(result, Ok(Some(Value::I32(7 as i32)))); + result.map(|_| ()) +} + +// Line 254 +fn c3_l254_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l254_action_invoke"); + let result = instance.call("multi", &[]); + assert_eq!(result, Ok(Some(Value::I32(8 as i32)))); + result.map(|_| ()) +} + +// Line 255 +fn c4_l255_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l255_action_invoke"); + let result = instance.call("nested", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 256 +fn c5_l256_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l256_action_invoke"); + let result = instance.call("deep", &[]); + assert_eq!(result, Ok(Some(Value::I32(150 as i32)))); + result.map(|_| ()) +} + +// Line 258 +fn c6_l258_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l258_action_invoke"); + let result = instance.call("as-select-first", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 259 +fn c7_l259_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l259_action_invoke"); + let result = instance.call("as-select-mid", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 260 +fn c8_l260_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l260_action_invoke"); + let result = instance.call("as-select-last", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 262 +fn c9_l262_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l262_action_invoke"); + let result = instance.call("as-loop-first", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 263 +fn c10_l263_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c10_l263_action_invoke"); + let result = instance.call("as-loop-mid", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 264 +fn c11_l264_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c11_l264_action_invoke"); + let result = instance.call("as-loop-last", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 266 +fn c12_l266_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c12_l266_action_invoke"); + let result = instance.call("as-if-condition", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 267 +fn c13_l267_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c13_l267_action_invoke"); + let result = instance.call("as-if-then", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 268 +fn c14_l268_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c14_l268_action_invoke"); + let result = instance.call("as-if-else", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 270 +fn c15_l270_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c15_l270_action_invoke"); + let result = instance.call("as-br_if-first", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 271 +fn c16_l271_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c16_l271_action_invoke"); + let result = instance.call("as-br_if-last", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 273 +fn c17_l273_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c17_l273_action_invoke"); + let result = instance.call("as-br_table-first", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 274 +fn c18_l274_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c18_l274_action_invoke"); + let result = instance.call("as-br_table-last", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 276 +fn c19_l276_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c19_l276_action_invoke"); + let result = instance.call("as-call_indirect-first", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 277 +fn c20_l277_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c20_l277_action_invoke"); + let result = instance.call("as-call_indirect-mid", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 278 +fn c21_l278_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c21_l278_action_invoke"); + let result = instance.call("as-call_indirect-last", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 280 +fn c22_l280_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c22_l280_action_invoke"); + let result = instance.call("as-store-first", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 281 +fn c23_l281_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c23_l281_action_invoke"); + let result = instance.call("as-store-last", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 283 +fn c24_l283_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c24_l283_action_invoke"); + let result = instance.call("as-memory.grow-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 284 +fn c25_l284_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c25_l284_action_invoke"); + let result = instance.call("as-call-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 285 +fn c26_l285_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c26_l285_action_invoke"); + let result = instance.call("as-return-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 286 +fn c27_l286_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c27_l286_action_invoke"); + let result = instance.call("as-drop-operand", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 287 +fn c28_l287_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c28_l287_action_invoke"); + let result = instance.call("as-br-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 288 +fn c29_l288_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c29_l288_action_invoke"); + let result = instance.call("as-set_local-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 289 +fn c30_l289_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c30_l289_action_invoke"); + let result = instance.call("as-tee_local-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 290 +fn c31_l290_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c31_l290_action_invoke"); + let result = instance.call("as-set_global-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 291 +fn c32_l291_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c32_l291_action_invoke"); + let result = instance.call("as-load-operand", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 293 +fn c33_l293_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c33_l293_action_invoke"); + let result = instance.call("as-unary-operand", &[]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 294 +fn c34_l294_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c34_l294_action_invoke"); + let result = instance.call("as-binary-operand", &[]); + assert_eq!(result, Ok(Some(Value::I32(12 as i32)))); + result.map(|_| ()) +} + +// Line 295 +fn c35_l295_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c35_l295_action_invoke"); + let result = instance.call("as-test-operand", &[]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 296 +fn c36_l296_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c36_l296_action_invoke"); + let result = instance.call("as-compare-operand", &[]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 298 +fn c37_l298_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c37_l298_action_invoke"); + let result = instance.call("break-bare", &[]); + assert_eq!(result, Ok(Some(Value::I32(19 as i32)))); + result.map(|_| ()) +} + +// Line 299 +fn c38_l299_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c38_l299_action_invoke"); + let result = instance.call("break-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(18 as i32)))); + result.map(|_| ()) +} + +// Line 300 +fn c39_l300_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c39_l300_action_invoke"); + let result = instance.call("break-repeated", &[]); + assert_eq!(result, Ok(Some(Value::I32(18 as i32)))); + result.map(|_| ()) +} + +// Line 301 +fn c40_l301_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c40_l301_action_invoke"); + let result = instance.call("break-inner", &[]); + assert_eq!(result, Ok(Some(Value::I32(15 as i32)))); + result.map(|_| ()) +} + +// Line 303 +fn c41_l303_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c41_l303_action_invoke"); + let result = instance.call("effects", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 306 +#[test] +fn c42_l306_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 7, 1, 5, 0, 2, 64, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 310 +#[test] +fn c43_l310_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 7, 1, 5, 0, 2, 64, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 314 +#[test] +fn c44_l314_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 7, 1, 5, 0, 2, 64, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 318 +#[test] +fn c45_l318_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 7, 1, 5, 0, 2, 64, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 323 +#[test] +fn c46_l323_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 64, 65, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 329 +#[test] +fn c47_l329_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 64, 66, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 335 +#[test] +fn c48_l335_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 67, 0, 0, 128, 63, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 341 +#[test] +fn c49_l341_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 64, 68, 0, 0, 0, 0, 0, 0, 240, 63, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 348 +#[test] +fn c50_l348_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 7, 1, 5, 0, 2, 127, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 354 +#[test] +fn c51_l354_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 7, 1, 5, 0, 2, 126, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 360 +#[test] +fn c52_l360_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 7, 1, 5, 0, 2, 125, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 366 +#[test] +fn c53_l366_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 7, 1, 5, 0, 2, 124, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 373 +#[test] +fn c54_l373_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 8, 1, 6, 0, 2, 127, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 379 +#[test] +fn c55_l379_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 8, 1, 6, 0, 2, 126, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 385 +#[test] +fn c56_l385_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 8, 1, 6, 0, 2, 125, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 391 +#[test] +fn c57_l391_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 8, 1, 6, 0, 2, 124, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 398 +#[test] +fn c58_l398_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 127, 66, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 404 +#[test] +fn c59_l404_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 127, 67, 0, 0, 0, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 410 +#[test] +fn c60_l410_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 127, 68, 0, 0, 0, 0, 0, 0, 0, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 416 +#[test] +fn c61_l416_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 126, 65, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 422 +#[test] +fn c62_l422_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 126, 67, 0, 0, 0, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 428 +#[test] +fn c63_l428_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 126, 68, 0, 0, 0, 0, 0, 0, 0, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 434 +#[test] +fn c64_l434_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 125, 65, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 440 +#[test] +fn c65_l440_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 125, 66, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 446 +#[test] +fn c66_l446_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 125, 68, 0, 0, 0, 0, 0, 0, 0, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 452 +#[test] +fn c67_l452_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 124, 65, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 458 +#[test] +fn c68_l458_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 124, 66, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 464 +#[test] +fn c69_l464_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 124, 67, 0, 0, 0, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 471 +#[test] +fn c70_l471_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 126, 0, 0, 0, 27, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 477 +#[test] +fn c71_l477_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 125, 0, 0, 0, 27, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 483 +#[test] +fn c72_l483_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 124, 0, 0, 0, 27, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 489 +#[test] +fn c73_l489_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 127, 0, 0, 0, 27, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 495 +#[test] +fn c74_l495_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 125, 0, 0, 0, 27, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 501 +#[test] +fn c75_l501_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 124, 0, 0, 0, 27, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 507 +#[test] +fn c76_l507_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 127, 0, 0, 0, 27, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 513 +#[test] +fn c77_l513_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 126, 0, 0, 0, 27, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 519 +#[test] +fn c78_l519_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 124, 0, 0, 0, 27, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 525 +#[test] +fn c79_l525_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 127, 0, 0, 0, 27, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 531 +#[test] +fn c80_l531_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 126, 0, 0, 0, 27, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 537 +#[test] +fn c81_l537_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 125, 0, 0, 0, 27, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 544 +#[test] +fn c82_l544_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 127, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 550 +#[test] +fn c83_l550_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 126, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 556 +#[test] +fn c84_l556_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 125, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 562 +#[test] +fn c85_l562_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 124, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 569 +#[test] +fn c86_l569_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 127, 12, 0, 65, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 575 +#[test] +fn c87_l575_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 126, 12, 0, 66, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 581 +#[test] +fn c88_l581_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 125, 12, 0, 67, 0, 0, 128, 63, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 587 +#[test] +fn c89_l587_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 124, 12, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 594 +#[test] +fn c90_l594_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 127, 1, 12, 0, 65, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 600 +#[test] +fn c91_l600_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 126, 1, 12, 0, 66, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 606 +#[test] +fn c92_l606_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 125, 1, 12, 0, 67, 0, 0, 128, 63, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 612 +#[test] +fn c93_l612_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 19, 1, 17, 0, 2, 124, 1, 12, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 619 +#[test] +fn c94_l619_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 127, 66, 1, 12, 0, 65, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 625 +#[test] +fn c95_l625_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 127, 67, 0, 0, 128, 63, 12, 0, 65, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 631 +#[test] +fn c96_l631_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 20, 1, 18, 0, 2, 127, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 65, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 637 +#[test] +fn c97_l637_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 126, 65, 1, 12, 0, 66, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 643 +#[test] +fn c98_l643_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 126, 67, 0, 0, 128, 63, 12, 0, 66, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 649 +#[test] +fn c99_l649_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 20, 1, 18, 0, 2, 126, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 66, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 655 +#[test] +fn c100_l655_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 125, 65, 1, 12, 0, 67, 0, 0, 128, 63, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 661 +#[test] +fn c101_l661_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 125, 66, 1, 12, 0, 67, 0, 0, 128, 63, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 667 +#[test] +fn c102_l667_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 23, 1, 21, 0, 2, 125, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 67, 0, 0, 128, 63, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 673 +#[test] +fn c103_l673_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 20, 1, 18, 0, 2, 126, 65, 1, 12, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 679 +#[test] +fn c104_l679_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 20, 1, 18, 0, 2, 124, 66, 1, 12, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 685 +#[test] +fn c105_l685_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 23, 1, 21, 0, 2, 124, 67, 0, 0, 128, 63, 12, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 692 +#[test] +fn c106_l692_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 127, 1, 12, 0, 65, 1, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 698 +#[test] +fn c107_l698_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 126, 1, 12, 0, 66, 1, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 704 +#[test] +fn c108_l704_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 17, 1, 15, 0, 2, 125, 1, 12, 0, 67, 0, 0, 128, 63, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 710 +#[test] +fn c109_l710_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 21, 1, 19, 0, 2, 124, 1, 12, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 717 +#[test] +fn c110_l717_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 127, 66, 1, 12, 0, 65, 1, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 723 +#[test] +fn c111_l723_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 127, 67, 0, 0, 128, 63, 12, 0, 65, 1, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 729 +#[test] +fn c112_l729_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 22, 1, 20, 0, 2, 127, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 65, 1, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 735 +#[test] +fn c113_l735_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 126, 65, 1, 12, 0, 66, 1, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 741 +#[test] +fn c114_l741_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 126, 67, 0, 0, 128, 63, 12, 0, 66, 1, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 747 +#[test] +fn c115_l747_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 22, 1, 20, 0, 2, 126, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 66, 1, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 753 +#[test] +fn c116_l753_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 125, 65, 1, 12, 0, 67, 0, 0, 128, 63, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 759 +#[test] +fn c117_l759_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 125, 66, 1, 12, 0, 67, 0, 0, 128, 63, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 765 +#[test] +fn c118_l765_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 25, 1, 23, 0, 2, 125, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 67, 0, 0, 128, 63, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 771 +#[test] +fn c119_l771_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 22, 1, 20, 0, 2, 124, 65, 1, 12, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 777 +#[test] +fn c120_l777_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 22, 1, 20, 0, 2, 124, 66, 1, 12, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 783 +#[test] +fn c121_l783_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 25, 1, 23, 0, 2, 124, 67, 0, 0, 128, 63, 12, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 790 +#[test] +fn c122_l790_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 127, 2, 127, 65, 1, 12, 1, 11, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 796 +#[test] +fn c123_l796_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 126, 2, 126, 66, 1, 12, 1, 11, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 802 +#[test] +fn c124_l802_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 19, 1, 17, 0, 2, 125, 2, 125, 67, 0, 0, 128, 63, 12, 1, 11, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 808 +#[test] +fn c125_l808_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 23, 1, 21, 0, 2, 124, 2, 124, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 1, 11, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 815 +#[test] +fn c126_l815_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 127, 2, 64, 12, 1, 11, 65, 1, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 821 +#[test] +fn c127_l821_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 126, 2, 64, 12, 1, 11, 66, 1, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 827 +#[test] +fn c128_l827_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 19, 1, 17, 0, 2, 125, 2, 64, 12, 1, 11, 67, 0, 0, 128, 63, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 833 +#[test] +fn c129_l833_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 23, 1, 21, 0, 2, 124, 2, 64, 12, 1, 11, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 840 +#[test] +fn c130_l840_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 17, 1, 15, 0, 2, 127, 2, 127, 1, 12, 1, 11, 65, 1, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 846 +#[test] +fn c131_l846_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 17, 1, 15, 0, 2, 126, 2, 126, 1, 12, 1, 11, 66, 1, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 852 +#[test] +fn c132_l852_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 20, 1, 18, 0, 2, 125, 2, 125, 1, 12, 1, 11, 67, 0, 0, 128, 63, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 858 +#[test] +fn c133_l858_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 24, 1, 22, 0, 2, 124, 2, 124, 1, 12, 1, 11, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 865 +#[test] +fn c134_l865_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 127, 2, 127, 66, 1, 12, 1, 11, 65, 1, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 873 +#[test] +fn c135_l873_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 21, 1, 19, 0, 2, 127, 2, 127, 67, 0, 0, 128, 63, 12, 1, 11, 65, 1, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 881 +#[test] +fn c136_l881_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 25, 1, 23, 0, 2, 127, 2, 127, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 1, 11, 65, 1, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 889 +#[test] +fn c137_l889_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 126, 2, 126, 65, 1, 12, 1, 11, 66, 1, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 897 +#[test] +fn c138_l897_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 21, 1, 19, 0, 2, 126, 2, 126, 67, 0, 0, 128, 63, 12, 1, 11, 66, 1, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 905 +#[test] +fn c139_l905_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 25, 1, 23, 0, 2, 126, 2, 126, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 1, 11, 66, 1, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 913 +#[test] +fn c140_l913_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 21, 1, 19, 0, 2, 125, 2, 125, 65, 1, 12, 1, 11, 67, 0, 0, 128, 63, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 921 +#[test] +fn c141_l921_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 21, 1, 19, 0, 2, 125, 2, 125, 66, 1, 12, 1, 11, 67, 0, 0, 128, 63, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 929 +#[test] +fn c142_l929_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 28, 1, 26, 0, 2, 125, 2, 125, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 1, 11, 67, 0, 0, 128, 63, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 937 +#[test] +fn c143_l937_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 25, 1, 23, 0, 2, 124, 2, 124, 65, 1, 12, 1, 11, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 945 +#[test] +fn c144_l945_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 25, 1, 23, 0, 2, 124, 2, 124, 66, 1, 12, 1, 11, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 953 +#[test] +fn c145_l953_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 28, 1, 26, 0, 2, 124, 2, 124, 67, 0, 0, 128, 63, 12, 1, 11, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 962 +#[test] +fn c146_l962_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 10, 1, 8, 0, 2, 64, 12, 0, 11, 104, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 968 +#[test] +fn c147_l968_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 10, 1, 8, 0, 2, 64, 12, 0, 11, 122, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 974 +#[test] +fn c148_l974_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 10, 1, 8, 0, 2, 64, 12, 0, 11, 142, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 980 +#[test] +fn c149_l980_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 10, 1, 8, 0, 2, 64, 12, 0, 11, 156, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 987 +#[test] +fn c150_l987_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 64, 1, 12, 0, 11, 104, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 993 +#[test] +fn c151_l993_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 64, 1, 12, 0, 11, 122, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 999 +#[test] +fn c152_l999_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 64, 1, 12, 0, 11, 142, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 1005 +#[test] +fn c153_l1005_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 64, 1, 12, 0, 11, 156, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 1012 +#[test] +fn c154_l1012_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 66, 9, 12, 0, 11, 122, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 1018 +#[test] +fn c155_l1018_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 64, 67, 0, 0, 16, 65, 12, 0, 11, 142, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 1024 +#[test] +fn c156_l1024_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 19, 1, 17, 0, 2, 64, 68, 0, 0, 0, 0, 0, 0, 34, 64, 12, 0, 11, 156, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 1030 +#[test] +fn c157_l1030_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 65, 9, 12, 0, 11, 104, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 1036 +#[test] +fn c158_l1036_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 64, 67, 0, 0, 16, 65, 12, 0, 11, 142, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 1042 +#[test] +fn c159_l1042_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 19, 1, 17, 0, 2, 64, 68, 0, 0, 0, 0, 0, 0, 34, 64, 12, 0, 11, 156, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 1048 +#[test] +fn c160_l1048_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 65, 9, 12, 0, 11, 104, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 1054 +#[test] +fn c161_l1054_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 66, 9, 12, 0, 11, 122, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 1060 +#[test] +fn c162_l1060_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 19, 1, 17, 0, 2, 64, 68, 0, 0, 0, 0, 0, 0, 34, 64, 12, 0, 11, 156, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 1066 +#[test] +fn c163_l1066_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 65, 9, 12, 0, 11, 104, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 1072 +#[test] +fn c164_l1072_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 66, 9, 12, 0, 11, 122, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 1078 +#[test] +fn c165_l1078_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 64, 67, 0, 0, 16, 65, 12, 0, 11, 142, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 1085 +#[test] +fn c166_l1085_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 98, 108, 111, 99, 107, 32, 101, 110, 100, 32, 36, 108, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 1089 +#[test] +fn c167_l1089_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 98, 108, 111, 99, 107, 32, 36, 97, 32, 101, 110, 100, 32, 36, 108, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l252_action_invoke(&mut instance); + c2_l253_action_invoke(&mut instance); + c3_l254_action_invoke(&mut instance); + c4_l255_action_invoke(&mut instance); + c5_l256_action_invoke(&mut instance); + c6_l258_action_invoke(&mut instance); + c7_l259_action_invoke(&mut instance); + c8_l260_action_invoke(&mut instance); + c9_l262_action_invoke(&mut instance); + c10_l263_action_invoke(&mut instance); + c11_l264_action_invoke(&mut instance); + c12_l266_action_invoke(&mut instance); + c13_l267_action_invoke(&mut instance); + c14_l268_action_invoke(&mut instance); + c15_l270_action_invoke(&mut instance); + c16_l271_action_invoke(&mut instance); + c17_l273_action_invoke(&mut instance); + c18_l274_action_invoke(&mut instance); + c19_l276_action_invoke(&mut instance); + c20_l277_action_invoke(&mut instance); + c21_l278_action_invoke(&mut instance); + c22_l280_action_invoke(&mut instance); + c23_l281_action_invoke(&mut instance); + c24_l283_action_invoke(&mut instance); + c25_l284_action_invoke(&mut instance); + c26_l285_action_invoke(&mut instance); + c27_l286_action_invoke(&mut instance); + c28_l287_action_invoke(&mut instance); + c29_l288_action_invoke(&mut instance); + c30_l289_action_invoke(&mut instance); + c31_l290_action_invoke(&mut instance); + c32_l291_action_invoke(&mut instance); + c33_l293_action_invoke(&mut instance); + c34_l294_action_invoke(&mut instance); + c35_l295_action_invoke(&mut instance); + c36_l296_action_invoke(&mut instance); + c37_l298_action_invoke(&mut instance); + c38_l299_action_invoke(&mut instance); + c39_l300_action_invoke(&mut instance); + c40_l301_action_invoke(&mut instance); + c41_l303_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/br.rs b/lib/runtime/tests/spectests/br.rs new file mode 100644 index 000000000..105aea9a9 --- /dev/null +++ b/lib/runtime/tests/spectests/br.rs @@ -0,0 +1,1208 @@ +// 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/br.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 3 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func (param i32 i32 i32) (result i32))) + (type (;1;) (func)) + (type (;2;) (func (result i32))) + (type (;3;) (func (result i64))) + (type (;4;) (func (result f32))) + (type (;5;) (func (result f64))) + (type (;6;) (func (param i32 i32) (result i32))) + (func (;0;) (type 1)) + (func (;1;) (type 1) + block ;; label = @1 + br 0 (;@1;) + i32.ctz + drop + end) + (func (;2;) (type 1) + block ;; label = @1 + br 0 (;@1;) + i64.ctz + drop + end) + (func (;3;) (type 1) + block ;; label = @1 + br 0 (;@1;) + f32.neg + drop + end) + (func (;4;) (type 1) + block ;; label = @1 + br 0 (;@1;) + f64.neg + drop + end) + (func (;5;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + br 0 (;@1;) + i32.ctz + end) + (func (;6;) (type 3) (result i64) + block (result i64) ;; label = @1 + i64.const 2 + br 0 (;@1;) + i64.ctz + end) + (func (;7;) (type 4) (result f32) + block (result f32) ;; label = @1 + f32.const 0x1.8p+1 (;=3;) + br 0 (;@1;) + f32.neg + end) + (func (;8;) (type 5) (result f64) + block (result f64) ;; label = @1 + f64.const 0x1p+2 (;=4;) + br 0 (;@1;) + f64.neg + end) + (func (;9;) (type 1) + block ;; label = @1 + br 0 (;@1;) + call 0 + end) + (func (;10;) (type 1) + block ;; label = @1 + call 0 + br 0 (;@1;) + call 0 + end) + (func (;11;) (type 1) + block ;; label = @1 + nop + call 0 + br 0 (;@1;) + end) + (func (;12;) (type 2) (result i32) + block (result i32) ;; label = @1 + nop + call 0 + i32.const 2 + br 0 (;@1;) + end) + (func (;13;) (type 2) (result i32) + block (result i32) ;; label = @1 + loop (result i32) ;; label = @2 + i32.const 3 + br 1 (;@1;) + i32.const 2 + end + end) + (func (;14;) (type 2) (result i32) + block (result i32) ;; label = @1 + loop (result i32) ;; label = @2 + call 0 + i32.const 4 + br 1 (;@1;) + i32.const 2 + end + end) + (func (;15;) (type 2) (result i32) + block (result i32) ;; label = @1 + loop (result i32) ;; label = @2 + nop + call 0 + i32.const 5 + br 1 (;@1;) + end + end) + (func (;16;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 9 + br 0 (;@1;) + br 0 (;@1;) + end) + (func (;17;) (type 1) + block ;; label = @1 + br 0 (;@1;) + br_if 0 (;@1;) + end) + (func (;18;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 8 + br 0 (;@1;) + i32.const 1 + br_if 0 (;@1;) + drop + i32.const 7 + end) + (func (;19;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 6 + i32.const 9 + br 0 (;@1;) + br_if 0 (;@1;) + drop + i32.const 7 + end) + (func (;20;) (type 1) + block ;; label = @1 + br 0 (;@1;) + br_table 0 (;@1;) 0 (;@1;) 0 (;@1;) + end) + (func (;21;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 10 + br 0 (;@1;) + i32.const 1 + br_table 0 (;@1;) 0 (;@1;) 0 (;@1;) + i32.const 7 + end) + (func (;22;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 6 + i32.const 11 + br 0 (;@1;) + br_table 0 (;@1;) 0 (;@1;) + i32.const 7 + end) + (func (;23;) (type 3) (result i64) + block (result i64) ;; label = @1 + i64.const 7 + br 0 (;@1;) + return + end) + (func (;24;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 2 + br 0 (;@1;) + if (result i32) ;; label = @2 + i32.const 0 + else + i32.const 1 + end + end) + (func (;25;) (type 6) (param i32 i32) (result i32) + block (result i32) ;; label = @1 + get_local 0 + if (result i32) ;; label = @2 + i32.const 3 + br 1 (;@1;) + else + get_local 1 + end + end) + (func (;26;) (type 6) (param i32 i32) (result i32) + block (result i32) ;; label = @1 + get_local 0 + if (result i32) ;; label = @2 + get_local 1 + else + i32.const 4 + br 1 (;@1;) + end + end) + (func (;27;) (type 6) (param i32 i32) (result i32) + block (result i32) ;; label = @1 + i32.const 5 + br 0 (;@1;) + get_local 0 + get_local 1 + select + end) + (func (;28;) (type 6) (param i32 i32) (result i32) + block (result i32) ;; label = @1 + get_local 0 + i32.const 6 + br 0 (;@1;) + get_local 1 + select + end) + (func (;29;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 0 + i32.const 1 + i32.const 7 + br 0 (;@1;) + select + end) + (func (;30;) (type 0) (param i32 i32 i32) (result i32) + i32.const -1) + (func (;31;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 12 + br 0 (;@1;) + i32.const 2 + i32.const 3 + call 30 + end) + (func (;32;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + i32.const 13 + br 0 (;@1;) + i32.const 3 + call 30 + end) + (func (;33;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + i32.const 2 + i32.const 14 + br 0 (;@1;) + call 30 + end) + (func (;34;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 20 + br 0 (;@1;) + i32.const 1 + i32.const 2 + i32.const 3 + call_indirect (type 0) + end) + (func (;35;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 0 + i32.const 21 + br 0 (;@1;) + i32.const 2 + i32.const 3 + call_indirect (type 0) + end) + (func (;36;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 0 + i32.const 1 + i32.const 22 + br 0 (;@1;) + i32.const 3 + call_indirect (type 0) + end) + (func (;37;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 0 + i32.const 1 + i32.const 2 + i32.const 23 + br 0 (;@1;) + call_indirect (type 0) + end) + (func (;38;) (type 2) (result i32) + (local f32) + block (result i32) ;; label = @1 + i32.const 17 + br 0 (;@1;) + set_local 0 + i32.const -1 + end) + (func (;39;) (type 2) (result i32) + (local i32) + block (result i32) ;; label = @1 + i32.const 1 + br 0 (;@1;) + tee_local 0 + end) + (func (;40;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + br 0 (;@1;) + set_global 0 + end) + (func (;41;) (type 4) (result f32) + block (result f32) ;; label = @1 + f32.const 0x1.b33334p+0 (;=1.7;) + br 0 (;@1;) + f32.load + end) + (func (;42;) (type 3) (result i64) + block (result i64) ;; label = @1 + i64.const 30 + br 0 (;@1;) + i64.load8_s + end) + (func (;43;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 30 + br 0 (;@1;) + f64.const 0x1.cp+2 (;=7;) + f64.store + i32.const -1 + end) + (func (;44;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 2 + i32.const 31 + br 0 (;@1;) + i64.store + i32.const -1 + end) + (func (;45;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 32 + br 0 (;@1;) + i32.const 7 + i32.store8 + i32.const -1 + end) + (func (;46;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 2 + i32.const 33 + br 0 (;@1;) + i64.store16 + i32.const -1 + end) + (func (;47;) (type 4) (result f32) + block (result f32) ;; label = @1 + f32.const 0x1.b33334p+1 (;=3.4;) + br 0 (;@1;) + f32.neg + end) + (func (;48;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 3 + br 0 (;@1;) + i32.const 10 + i32.add + end) + (func (;49;) (type 3) (result i64) + block (result i64) ;; label = @1 + i64.const 10 + i64.const 45 + br 0 (;@1;) + i64.sub + end) + (func (;50;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 44 + br 0 (;@1;) + i32.eqz + end) + (func (;51;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 43 + br 0 (;@1;) + f64.const 0x1.4p+3 (;=10;) + f64.le + end) + (func (;52;) (type 2) (result i32) + block (result i32) ;; label = @1 + f32.const 0x1.4p+3 (;=10;) + i32.const 42 + br 0 (;@1;) + f32.ne + end) + (func (;53;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 41 + br 0 (;@1;) + i32.wrap/i64 + end) + (func (;54;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 40 + br 0 (;@1;) + memory.grow + end) + (func (;55;) (type 2) (result i32) + i32.const 1 + block (result i32) ;; label = @1 + call 0 + i32.const 4 + i32.const 8 + br 0 (;@1;) + i32.add + end + i32.add) + (func (;56;) (type 2) (result i32) + i32.const 1 + block (result i32) ;; label = @1 + i32.const 2 + drop + block (result i32) ;; label = @2 + i32.const 4 + drop + i32.const 8 + br 1 (;@1;) + br 0 (;@2;) + end + drop + i32.const 16 + end + i32.add) + (func (;57;) (type 2) (result i32) + i32.const 1 + block (result i32) ;; label = @1 + i32.const 2 + drop + block (result i32) ;; label = @2 + i32.const 4 + drop + i32.const 8 + br 1 (;@1;) + i32.const 1 + br_if 0 (;@2;) + drop + i32.const 32 + end + drop + i32.const 16 + end + i32.add) + (func (;58;) (type 2) (result i32) + i32.const 1 + block (result i32) ;; label = @1 + i32.const 2 + drop + i32.const 4 + i32.const 8 + br 0 (;@1;) + br_if 0 (;@1;) + drop + i32.const 16 + end + i32.add) + (func (;59;) (type 2) (result i32) + i32.const 1 + block (result i32) ;; label = @1 + i32.const 2 + drop + block (result i32) ;; label = @2 + i32.const 4 + drop + i32.const 8 + br 1 (;@1;) + i32.const 1 + br_table 0 (;@2;) + end + drop + i32.const 16 + end + i32.add) + (func (;60;) (type 2) (result i32) + i32.const 1 + block (result i32) ;; label = @1 + i32.const 2 + drop + i32.const 4 + i32.const 8 + br 0 (;@1;) + br_table 0 (;@1;) + i32.const 16 + end + i32.add) + (table (;0;) 1 1 anyfunc) + (memory (;0;) 1) + (global (;0;) (mut i32) (i32.const 10)) + (export \"type-i32\" (func 1)) + (export \"type-i64\" (func 2)) + (export \"type-f32\" (func 3)) + (export \"type-f64\" (func 4)) + (export \"type-i32-value\" (func 5)) + (export \"type-i64-value\" (func 6)) + (export \"type-f32-value\" (func 7)) + (export \"type-f64-value\" (func 8)) + (export \"as-block-first\" (func 9)) + (export \"as-block-mid\" (func 10)) + (export \"as-block-last\" (func 11)) + (export \"as-block-value\" (func 12)) + (export \"as-loop-first\" (func 13)) + (export \"as-loop-mid\" (func 14)) + (export \"as-loop-last\" (func 15)) + (export \"as-br-value\" (func 16)) + (export \"as-br_if-cond\" (func 17)) + (export \"as-br_if-value\" (func 18)) + (export \"as-br_if-value-cond\" (func 19)) + (export \"as-br_table-index\" (func 20)) + (export \"as-br_table-value\" (func 21)) + (export \"as-br_table-value-index\" (func 22)) + (export \"as-return-value\" (func 23)) + (export \"as-if-cond\" (func 24)) + (export \"as-if-then\" (func 25)) + (export \"as-if-else\" (func 26)) + (export \"as-select-first\" (func 27)) + (export \"as-select-second\" (func 28)) + (export \"as-select-cond\" (func 29)) + (export \"as-call-first\" (func 31)) + (export \"as-call-mid\" (func 32)) + (export \"as-call-last\" (func 33)) + (export \"as-call_indirect-func\" (func 34)) + (export \"as-call_indirect-first\" (func 35)) + (export \"as-call_indirect-mid\" (func 36)) + (export \"as-call_indirect-last\" (func 37)) + (export \"as-set_local-value\" (func 38)) + (export \"as-tee_local-value\" (func 39)) + (export \"as-set_global-value\" (func 40)) + (export \"as-load-address\" (func 41)) + (export \"as-loadN-address\" (func 42)) + (export \"as-store-address\" (func 43)) + (export \"as-store-value\" (func 44)) + (export \"as-storeN-address\" (func 45)) + (export \"as-storeN-value\" (func 46)) + (export \"as-unary-operand\" (func 47)) + (export \"as-binary-left\" (func 48)) + (export \"as-binary-right\" (func 49)) + (export \"as-test-operand\" (func 50)) + (export \"as-compare-left\" (func 51)) + (export \"as-compare-right\" (func 52)) + (export \"as-convert-operand\" (func 53)) + (export \"as-memory.grow-size\" (func 54)) + (export \"nested-block-value\" (func 55)) + (export \"nested-br-value\" (func 56)) + (export \"nested-br_if-value\" (func 57)) + (export \"nested-br_if-value-cond\" (func 58)) + (export \"nested-br_table-value\" (func 59)) + (export \"nested-br_table-value-index\" (func 60)) + (elem (;0;) (i32.const 0) 30)) + "; + 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 334 +fn c1_l334_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l334_action_invoke"); + let result = instance.call("type-i32", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 335 +fn c2_l335_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l335_action_invoke"); + let result = instance.call("type-i64", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 336 +fn c3_l336_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l336_action_invoke"); + let result = instance.call("type-f32", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 337 +fn c4_l337_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l337_action_invoke"); + let result = instance.call("type-f64", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 339 +fn c5_l339_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l339_action_invoke"); + let result = instance.call("type-i32-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 340 +fn c6_l340_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l340_action_invoke"); + let result = instance.call("type-i64-value", &[]); + assert_eq!(result, Ok(Some(Value::I64(2 as i64)))); + result.map(|_| ()) +} + +// Line 341 +fn c7_l341_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l341_action_invoke"); + let result = instance.call("type-f32-value", &[]); + assert_eq!(result, Ok(Some(Value::F32((3.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 342 +fn c8_l342_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l342_action_invoke"); + let result = instance.call("type-f64-value", &[]); + assert_eq!(result, Ok(Some(Value::F64((4.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 344 +fn c9_l344_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l344_action_invoke"); + let result = instance.call("as-block-first", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 345 +fn c10_l345_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c10_l345_action_invoke"); + let result = instance.call("as-block-mid", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 346 +fn c11_l346_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c11_l346_action_invoke"); + let result = instance.call("as-block-last", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 347 +fn c12_l347_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c12_l347_action_invoke"); + let result = instance.call("as-block-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 349 +fn c13_l349_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c13_l349_action_invoke"); + let result = instance.call("as-loop-first", &[]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 350 +fn c14_l350_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c14_l350_action_invoke"); + let result = instance.call("as-loop-mid", &[]); + assert_eq!(result, Ok(Some(Value::I32(4 as i32)))); + result.map(|_| ()) +} + +// Line 351 +fn c15_l351_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c15_l351_action_invoke"); + let result = instance.call("as-loop-last", &[]); + assert_eq!(result, Ok(Some(Value::I32(5 as i32)))); + result.map(|_| ()) +} + +// Line 353 +fn c16_l353_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c16_l353_action_invoke"); + let result = instance.call("as-br-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 355 +fn c17_l355_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c17_l355_action_invoke"); + let result = instance.call("as-br_if-cond", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 356 +fn c18_l356_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c18_l356_action_invoke"); + let result = instance.call("as-br_if-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(8 as i32)))); + result.map(|_| ()) +} + +// Line 357 +fn c19_l357_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c19_l357_action_invoke"); + let result = instance.call("as-br_if-value-cond", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 359 +fn c20_l359_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c20_l359_action_invoke"); + let result = instance.call("as-br_table-index", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 360 +fn c21_l360_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c21_l360_action_invoke"); + let result = instance.call("as-br_table-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); + result.map(|_| ()) +} + +// Line 361 +fn c22_l361_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c22_l361_action_invoke"); + let result = instance.call("as-br_table-value-index", &[]); + assert_eq!(result, Ok(Some(Value::I32(11 as i32)))); + result.map(|_| ()) +} + +// Line 363 +fn c23_l363_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c23_l363_action_invoke"); + let result = instance.call("as-return-value", &[]); + assert_eq!(result, Ok(Some(Value::I64(7 as i64)))); + result.map(|_| ()) +} + +// Line 365 +fn c24_l365_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c24_l365_action_invoke"); + let result = instance.call("as-if-cond", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 366 +fn c25_l366_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c25_l366_action_invoke"); + let result = instance.call("as-if-then", &[Value::I32(1 as i32), Value::I32(6 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 367 +fn c26_l367_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c26_l367_action_invoke"); + let result = instance.call("as-if-then", &[Value::I32(0 as i32), Value::I32(6 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); + result.map(|_| ()) +} + +// Line 368 +fn c27_l368_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c27_l368_action_invoke"); + let result = instance.call("as-if-else", &[Value::I32(0 as i32), Value::I32(6 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(4 as i32)))); + result.map(|_| ()) +} + +// Line 369 +fn c28_l369_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c28_l369_action_invoke"); + let result = instance.call("as-if-else", &[Value::I32(1 as i32), Value::I32(6 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); + result.map(|_| ()) +} + +// Line 371 +fn c29_l371_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c29_l371_action_invoke"); + let result = instance.call("as-select-first", &[Value::I32(0 as i32), Value::I32(6 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(5 as i32)))); + result.map(|_| ()) +} + +// Line 372 +fn c30_l372_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c30_l372_action_invoke"); + let result = instance.call("as-select-first", &[Value::I32(1 as i32), Value::I32(6 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(5 as i32)))); + result.map(|_| ()) +} + +// Line 373 +fn c31_l373_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c31_l373_action_invoke"); + let result = instance.call("as-select-second", &[Value::I32(0 as i32), Value::I32(6 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); + result.map(|_| ()) +} + +// Line 374 +fn c32_l374_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c32_l374_action_invoke"); + let result = instance.call("as-select-second", &[Value::I32(1 as i32), Value::I32(6 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); + result.map(|_| ()) +} + +// Line 375 +fn c33_l375_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c33_l375_action_invoke"); + let result = instance.call("as-select-cond", &[]); + assert_eq!(result, Ok(Some(Value::I32(7 as i32)))); + result.map(|_| ()) +} + +// Line 377 +fn c34_l377_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c34_l377_action_invoke"); + let result = instance.call("as-call-first", &[]); + assert_eq!(result, Ok(Some(Value::I32(12 as i32)))); + result.map(|_| ()) +} + +// Line 378 +fn c35_l378_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c35_l378_action_invoke"); + let result = instance.call("as-call-mid", &[]); + assert_eq!(result, Ok(Some(Value::I32(13 as i32)))); + result.map(|_| ()) +} + +// Line 379 +fn c36_l379_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c36_l379_action_invoke"); + let result = instance.call("as-call-last", &[]); + assert_eq!(result, Ok(Some(Value::I32(14 as i32)))); + result.map(|_| ()) +} + +// Line 381 +fn c37_l381_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c37_l381_action_invoke"); + let result = instance.call("as-call_indirect-func", &[]); + assert_eq!(result, Ok(Some(Value::I32(20 as i32)))); + result.map(|_| ()) +} + +// Line 382 +fn c38_l382_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c38_l382_action_invoke"); + let result = instance.call("as-call_indirect-first", &[]); + assert_eq!(result, Ok(Some(Value::I32(21 as i32)))); + result.map(|_| ()) +} + +// Line 383 +fn c39_l383_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c39_l383_action_invoke"); + let result = instance.call("as-call_indirect-mid", &[]); + assert_eq!(result, Ok(Some(Value::I32(22 as i32)))); + result.map(|_| ()) +} + +// Line 384 +fn c40_l384_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c40_l384_action_invoke"); + let result = instance.call("as-call_indirect-last", &[]); + assert_eq!(result, Ok(Some(Value::I32(23 as i32)))); + result.map(|_| ()) +} + +// Line 386 +fn c41_l386_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c41_l386_action_invoke"); + let result = instance.call("as-set_local-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(17 as i32)))); + result.map(|_| ()) +} + +// Line 387 +fn c42_l387_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c42_l387_action_invoke"); + let result = instance.call("as-tee_local-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 388 +fn c43_l388_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c43_l388_action_invoke"); + let result = instance.call("as-set_global-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 390 +fn c44_l390_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c44_l390_action_invoke"); + let result = instance.call("as-load-address", &[]); + assert_eq!(result, Ok(Some(Value::F32((1.7f32).to_bits())))); + result.map(|_| ()) +} + +// Line 391 +fn c45_l391_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c45_l391_action_invoke"); + let result = instance.call("as-loadN-address", &[]); + assert_eq!(result, Ok(Some(Value::I64(30 as i64)))); + result.map(|_| ()) +} + +// Line 393 +fn c46_l393_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c46_l393_action_invoke"); + let result = instance.call("as-store-address", &[]); + assert_eq!(result, Ok(Some(Value::I32(30 as i32)))); + result.map(|_| ()) +} + +// Line 394 +fn c47_l394_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c47_l394_action_invoke"); + let result = instance.call("as-store-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(31 as i32)))); + result.map(|_| ()) +} + +// Line 395 +fn c48_l395_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c48_l395_action_invoke"); + let result = instance.call("as-storeN-address", &[]); + assert_eq!(result, Ok(Some(Value::I32(32 as i32)))); + result.map(|_| ()) +} + +// Line 396 +fn c49_l396_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c49_l396_action_invoke"); + let result = instance.call("as-storeN-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(33 as i32)))); + result.map(|_| ()) +} + +// Line 398 +fn c50_l398_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c50_l398_action_invoke"); + let result = instance.call("as-unary-operand", &[]); + assert_eq!(result, Ok(Some(Value::F32((3.4f32).to_bits())))); + result.map(|_| ()) +} + +// Line 400 +fn c51_l400_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c51_l400_action_invoke"); + let result = instance.call("as-binary-left", &[]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 401 +fn c52_l401_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c52_l401_action_invoke"); + let result = instance.call("as-binary-right", &[]); + assert_eq!(result, Ok(Some(Value::I64(45 as i64)))); + result.map(|_| ()) +} + +// Line 403 +fn c53_l403_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c53_l403_action_invoke"); + let result = instance.call("as-test-operand", &[]); + assert_eq!(result, Ok(Some(Value::I32(44 as i32)))); + result.map(|_| ()) +} + +// Line 405 +fn c54_l405_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c54_l405_action_invoke"); + let result = instance.call("as-compare-left", &[]); + assert_eq!(result, Ok(Some(Value::I32(43 as i32)))); + result.map(|_| ()) +} + +// Line 406 +fn c55_l406_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c55_l406_action_invoke"); + let result = instance.call("as-compare-right", &[]); + assert_eq!(result, Ok(Some(Value::I32(42 as i32)))); + result.map(|_| ()) +} + +// Line 408 +fn c56_l408_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c56_l408_action_invoke"); + let result = instance.call("as-convert-operand", &[]); + assert_eq!(result, Ok(Some(Value::I32(41 as i32)))); + result.map(|_| ()) +} + +// Line 410 +fn c57_l410_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c57_l410_action_invoke"); + let result = instance.call("as-memory.grow-size", &[]); + assert_eq!(result, Ok(Some(Value::I32(40 as i32)))); + result.map(|_| ()) +} + +// Line 412 +fn c58_l412_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c58_l412_action_invoke"); + let result = instance.call("nested-block-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 413 +fn c59_l413_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c59_l413_action_invoke"); + let result = instance.call("nested-br-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 414 +fn c60_l414_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c60_l414_action_invoke"); + let result = instance.call("nested-br_if-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 415 +fn c61_l415_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c61_l415_action_invoke"); + let result = instance.call("nested-br_if-value-cond", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 416 +fn c62_l416_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c62_l416_action_invoke"); + let result = instance.call("nested-br_table-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 417 +fn c63_l417_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c63_l417_action_invoke"); + let result = instance.call("nested-br_table-value-index", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 420 +#[test] +fn c64_l420_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 127, 12, 0, 65, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 427 +#[test] +fn c65_l427_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 127, 1, 12, 0, 65, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 433 +#[test] +fn c66_l433_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 127, 65, 0, 2, 64, 12, 1, 11, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 439 +#[test] +fn c67_l439_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 127, 66, 1, 12, 0, 65, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 446 +#[test] +fn c68_l446_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 6, 1, 4, 0, 12, 1, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 450 +#[test] +fn c69_l450_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 2, 64, 12, 5, 11, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 454 +#[test] +fn c70_l454_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 10, 1, 8, 0, 12, 129, 128, 128, 128, 1, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l334_action_invoke(&mut instance); + c2_l335_action_invoke(&mut instance); + c3_l336_action_invoke(&mut instance); + c4_l337_action_invoke(&mut instance); + c5_l339_action_invoke(&mut instance); + c6_l340_action_invoke(&mut instance); + c7_l341_action_invoke(&mut instance); + c8_l342_action_invoke(&mut instance); + c9_l344_action_invoke(&mut instance); + c10_l345_action_invoke(&mut instance); + c11_l346_action_invoke(&mut instance); + c12_l347_action_invoke(&mut instance); + c13_l349_action_invoke(&mut instance); + c14_l350_action_invoke(&mut instance); + c15_l351_action_invoke(&mut instance); + c16_l353_action_invoke(&mut instance); + c17_l355_action_invoke(&mut instance); + c18_l356_action_invoke(&mut instance); + c19_l357_action_invoke(&mut instance); + c20_l359_action_invoke(&mut instance); + c21_l360_action_invoke(&mut instance); + c22_l361_action_invoke(&mut instance); + c23_l363_action_invoke(&mut instance); + c24_l365_action_invoke(&mut instance); + c25_l366_action_invoke(&mut instance); + c26_l367_action_invoke(&mut instance); + c27_l368_action_invoke(&mut instance); + c28_l369_action_invoke(&mut instance); + c29_l371_action_invoke(&mut instance); + c30_l372_action_invoke(&mut instance); + c31_l373_action_invoke(&mut instance); + c32_l374_action_invoke(&mut instance); + c33_l375_action_invoke(&mut instance); + c34_l377_action_invoke(&mut instance); + c35_l378_action_invoke(&mut instance); + c36_l379_action_invoke(&mut instance); + c37_l381_action_invoke(&mut instance); + c38_l382_action_invoke(&mut instance); + c39_l383_action_invoke(&mut instance); + c40_l384_action_invoke(&mut instance); + c41_l386_action_invoke(&mut instance); + c42_l387_action_invoke(&mut instance); + c43_l388_action_invoke(&mut instance); + c44_l390_action_invoke(&mut instance); + c45_l391_action_invoke(&mut instance); + c46_l393_action_invoke(&mut instance); + c47_l394_action_invoke(&mut instance); + c48_l395_action_invoke(&mut instance); + c49_l396_action_invoke(&mut instance); + c50_l398_action_invoke(&mut instance); + c51_l400_action_invoke(&mut instance); + c52_l401_action_invoke(&mut instance); + c53_l403_action_invoke(&mut instance); + c54_l405_action_invoke(&mut instance); + c55_l406_action_invoke(&mut instance); + c56_l408_action_invoke(&mut instance); + c57_l410_action_invoke(&mut instance); + c58_l412_action_invoke(&mut instance); + c59_l413_action_invoke(&mut instance); + c60_l414_action_invoke(&mut instance); + c61_l415_action_invoke(&mut instance); + c62_l416_action_invoke(&mut instance); + c63_l417_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/br_if.rs b/lib/runtime/tests/spectests/br_if.rs new file mode 100644 index 000000000..b0cbd3549 --- /dev/null +++ b/lib/runtime/tests/spectests/br_if.rs @@ -0,0 +1,1500 @@ +// 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/br_if.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 3 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func (param i32 i32 i32) (result i32))) + (type (;1;) (func)) + (type (;2;) (func (result i32))) + (type (;3;) (func (result i64))) + (type (;4;) (func (result f32))) + (type (;5;) (func (result f64))) + (type (;6;) (func (param i32) (result i32))) + (type (;7;) (func (param i32))) + (type (;8;) (func (param i32 i32))) + (func (;0;) (type 1)) + (func (;1;) (type 1) + block ;; label = @1 + i32.const 0 + i32.const 1 + br_if 0 (;@1;) + i32.ctz + drop + end) + (func (;2;) (type 1) + block ;; label = @1 + i64.const 0 + i32.const 1 + br_if 0 (;@1;) + i64.ctz + drop + end) + (func (;3;) (type 1) + block ;; label = @1 + f32.const 0x0p+0 (;=0;) + i32.const 1 + br_if 0 (;@1;) + f32.neg + drop + end) + (func (;4;) (type 1) + block ;; label = @1 + f64.const 0x0p+0 (;=0;) + i32.const 1 + br_if 0 (;@1;) + f64.neg + drop + end) + (func (;5;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + i32.const 1 + br_if 0 (;@1;) + i32.ctz + end) + (func (;6;) (type 3) (result i64) + block (result i64) ;; label = @1 + i64.const 2 + i32.const 1 + br_if 0 (;@1;) + i64.ctz + end) + (func (;7;) (type 4) (result f32) + block (result f32) ;; label = @1 + f32.const 0x1.8p+1 (;=3;) + i32.const 1 + br_if 0 (;@1;) + f32.neg + end) + (func (;8;) (type 5) (result f64) + block (result f64) ;; label = @1 + f64.const 0x1p+2 (;=4;) + i32.const 1 + br_if 0 (;@1;) + f64.neg + end) + (func (;9;) (type 6) (param i32) (result i32) + block ;; label = @1 + get_local 0 + br_if 0 (;@1;) + i32.const 2 + return + end + i32.const 3) + (func (;10;) (type 6) (param i32) (result i32) + block ;; label = @1 + call 0 + get_local 0 + br_if 0 (;@1;) + i32.const 2 + return + end + i32.const 3) + (func (;11;) (type 7) (param i32) + block ;; label = @1 + call 0 + call 0 + get_local 0 + br_if 0 (;@1;) + end) + (func (;12;) (type 6) (param i32) (result i32) + block (result i32) ;; label = @1 + i32.const 10 + get_local 0 + br_if 0 (;@1;) + drop + i32.const 11 + return + end) + (func (;13;) (type 6) (param i32) (result i32) + block (result i32) ;; label = @1 + call 0 + i32.const 20 + get_local 0 + br_if 0 (;@1;) + drop + i32.const 21 + return + end) + (func (;14;) (type 6) (param i32) (result i32) + block (result i32) ;; label = @1 + call 0 + call 0 + i32.const 11 + get_local 0 + br_if 0 (;@1;) + end) + (func (;15;) (type 6) (param i32) (result i32) + block ;; label = @1 + loop ;; label = @2 + get_local 0 + br_if 1 (;@1;) + i32.const 2 + return + end + end + i32.const 3) + (func (;16;) (type 6) (param i32) (result i32) + block ;; label = @1 + loop ;; label = @2 + call 0 + get_local 0 + br_if 1 (;@1;) + i32.const 2 + return + end + end + i32.const 4) + (func (;17;) (type 7) (param i32) + loop ;; label = @1 + call 0 + get_local 0 + br_if 1 (;@0;) + end) + (func (;18;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + i32.const 2 + br_if 0 (;@1;) + br 0 (;@1;) + end) + (func (;19;) (type 1) + block ;; label = @1 + i32.const 1 + i32.const 1 + br_if 0 (;@1;) + br_if 0 (;@1;) + end) + (func (;20;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + i32.const 2 + br_if 0 (;@1;) + i32.const 3 + br_if 0 (;@1;) + drop + i32.const 4 + end) + (func (;21;) (type 6) (param i32) (result i32) + block (result i32) ;; label = @1 + i32.const 2 + i32.const 1 + get_local 0 + br_if 0 (;@1;) + br_if 0 (;@1;) + drop + i32.const 4 + end) + (func (;22;) (type 1) + block ;; label = @1 + i32.const 1 + i32.const 2 + br_if 0 (;@1;) + br_table 0 (;@1;) 0 (;@1;) 0 (;@1;) + end) + (func (;23;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + i32.const 2 + br_if 0 (;@1;) + i32.const 3 + br_table 0 (;@1;) 0 (;@1;) 0 (;@1;) + i32.const 4 + end) + (func (;24;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 2 + i32.const 1 + i32.const 3 + br_if 0 (;@1;) + br_table 0 (;@1;) 0 (;@1;) + i32.const 4 + end) + (func (;25;) (type 3) (result i64) + block (result i64) ;; label = @1 + i64.const 1 + i32.const 2 + br_if 0 (;@1;) + return + end) + (func (;26;) (type 6) (param i32) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + get_local 0 + br_if 0 (;@1;) + if (result i32) ;; label = @2 + i32.const 2 + else + i32.const 3 + end + end) + (func (;27;) (type 8) (param i32 i32) + block ;; label = @1 + get_local 0 + if ;; label = @2 + get_local 1 + br_if 1 (;@1;) + else + call 0 + end + end) + (func (;28;) (type 8) (param i32 i32) + block ;; label = @1 + get_local 0 + if ;; label = @2 + call 0 + else + get_local 1 + br_if 1 (;@1;) + end + end) + (func (;29;) (type 6) (param i32) (result i32) + block (result i32) ;; label = @1 + i32.const 3 + i32.const 10 + br_if 0 (;@1;) + i32.const 2 + get_local 0 + select + end) + (func (;30;) (type 6) (param i32) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + i32.const 3 + i32.const 10 + br_if 0 (;@1;) + get_local 0 + select + end) + (func (;31;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + i32.const 2 + i32.const 3 + i32.const 10 + br_if 0 (;@1;) + select + end) + (func (;32;) (type 0) (param i32 i32 i32) (result i32) + i32.const -1) + (func (;33;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 12 + i32.const 1 + br_if 0 (;@1;) + i32.const 2 + i32.const 3 + call 32 + end) + (func (;34;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + i32.const 13 + i32.const 1 + br_if 0 (;@1;) + i32.const 3 + call 32 + end) + (func (;35;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + i32.const 2 + i32.const 14 + i32.const 1 + br_if 0 (;@1;) + call 32 + end) + (func (;36;) (type 0) (param i32 i32 i32) (result i32) + get_local 0) + (func (;37;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 4 + i32.const 10 + br_if 0 (;@1;) + i32.const 1 + i32.const 2 + i32.const 0 + call_indirect (type 0) + end) + (func (;38;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + i32.const 4 + i32.const 10 + br_if 0 (;@1;) + i32.const 2 + i32.const 0 + call_indirect (type 0) + end) + (func (;39;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + i32.const 2 + i32.const 4 + i32.const 10 + br_if 0 (;@1;) + i32.const 0 + call_indirect (type 0) + end) + (func (;40;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + i32.const 2 + i32.const 3 + i32.const 4 + i32.const 10 + br_if 0 (;@1;) + call_indirect (type 0) + end) + (func (;41;) (type 6) (param i32) (result i32) + (local i32) + block (result i32) ;; label = @1 + i32.const 17 + get_local 0 + br_if 0 (;@1;) + set_local 0 + i32.const -1 + end) + (func (;42;) (type 6) (param i32) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + get_local 0 + br_if 0 (;@1;) + tee_local 0 + i32.const -1 + return + end) + (func (;43;) (type 6) (param i32) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + get_local 0 + br_if 0 (;@1;) + set_global 0 + i32.const -1 + return + end) + (func (;44;) (type 5) (result f64) + block (result f64) ;; label = @1 + f64.const 0x1p+0 (;=1;) + i32.const 1 + br_if 0 (;@1;) + f64.neg + end) + (func (;45;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + i32.const 1 + br_if 0 (;@1;) + i32.const 10 + i32.add + end) + (func (;46;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 10 + i32.const 1 + i32.const 1 + br_if 0 (;@1;) + i32.sub + end) + (func (;47;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + i32.const 1 + br_if 0 (;@1;) + memory.grow + end) + (func (;48;) (type 6) (param i32) (result i32) + i32.const 1 + block (result i32) ;; label = @1 + i32.const 2 + drop + i32.const 4 + block (result i32) ;; label = @2 + i32.const 8 + get_local 0 + br_if 1 (;@1;) + drop + i32.const 16 + end + i32.add + end + i32.add) + (func (;49;) (type 6) (param i32) (result i32) + i32.const 1 + block (result i32) ;; label = @1 + i32.const 2 + drop + block (result i32) ;; label = @2 + i32.const 8 + get_local 0 + br_if 1 (;@1;) + drop + i32.const 4 + end + br 0 (;@1;) + i32.const 16 + end + i32.add) + (func (;50;) (type 6) (param i32) (result i32) + i32.const 1 + block (result i32) ;; label = @1 + i32.const 2 + drop + block (result i32) ;; label = @2 + i32.const 8 + get_local 0 + br_if 1 (;@1;) + drop + i32.const 4 + end + i32.const 1 + br_if 0 (;@1;) + drop + i32.const 16 + end + i32.add) + (func (;51;) (type 6) (param i32) (result i32) + i32.const 1 + block (result i32) ;; label = @1 + i32.const 2 + drop + i32.const 4 + block (result i32) ;; label = @2 + i32.const 8 + get_local 0 + br_if 1 (;@1;) + drop + i32.const 1 + end + br_if 0 (;@1;) + drop + i32.const 16 + end + i32.add) + (func (;52;) (type 6) (param i32) (result i32) + i32.const 1 + block (result i32) ;; label = @1 + i32.const 2 + drop + block (result i32) ;; label = @2 + i32.const 8 + get_local 0 + br_if 1 (;@1;) + drop + i32.const 4 + end + i32.const 1 + br_table 0 (;@1;) + i32.const 16 + end + i32.add) + (func (;53;) (type 6) (param i32) (result i32) + i32.const 1 + block (result i32) ;; label = @1 + i32.const 2 + drop + i32.const 4 + block (result i32) ;; label = @2 + i32.const 8 + get_local 0 + br_if 1 (;@1;) + drop + i32.const 1 + end + br_table 0 (;@1;) + i32.const 16 + end + i32.add) + (table (;0;) 1 1 anyfunc) + (memory (;0;) 0) + (global (;0;) (mut i32) (i32.const 10)) + (export \"type-i32\" (func 1)) + (export \"type-i64\" (func 2)) + (export \"type-f32\" (func 3)) + (export \"type-f64\" (func 4)) + (export \"type-i32-value\" (func 5)) + (export \"type-i64-value\" (func 6)) + (export \"type-f32-value\" (func 7)) + (export \"type-f64-value\" (func 8)) + (export \"as-block-first\" (func 9)) + (export \"as-block-mid\" (func 10)) + (export \"as-block-last\" (func 11)) + (export \"as-block-first-value\" (func 12)) + (export \"as-block-mid-value\" (func 13)) + (export \"as-block-last-value\" (func 14)) + (export \"as-loop-first\" (func 15)) + (export \"as-loop-mid\" (func 16)) + (export \"as-loop-last\" (func 17)) + (export \"as-br-value\" (func 18)) + (export \"as-br_if-cond\" (func 19)) + (export \"as-br_if-value\" (func 20)) + (export \"as-br_if-value-cond\" (func 21)) + (export \"as-br_table-index\" (func 22)) + (export \"as-br_table-value\" (func 23)) + (export \"as-br_table-value-index\" (func 24)) + (export \"as-return-value\" (func 25)) + (export \"as-if-cond\" (func 26)) + (export \"as-if-then\" (func 27)) + (export \"as-if-else\" (func 28)) + (export \"as-select-first\" (func 29)) + (export \"as-select-second\" (func 30)) + (export \"as-select-cond\" (func 31)) + (export \"as-call-first\" (func 33)) + (export \"as-call-mid\" (func 34)) + (export \"as-call-last\" (func 35)) + (export \"as-call_indirect-func\" (func 37)) + (export \"as-call_indirect-first\" (func 38)) + (export \"as-call_indirect-mid\" (func 39)) + (export \"as-call_indirect-last\" (func 40)) + (export \"as-set_local-value\" (func 41)) + (export \"as-tee_local-value\" (func 42)) + (export \"as-set_global-value\" (func 43)) + (export \"as-unary-operand\" (func 44)) + (export \"as-binary-left\" (func 45)) + (export \"as-binary-right\" (func 46)) + (export \"as-memory.grow-size\" (func 47)) + (export \"nested-block-value\" (func 48)) + (export \"nested-br-value\" (func 49)) + (export \"nested-br_if-value\" (func 50)) + (export \"nested-br_if-value-cond\" (func 51)) + (export \"nested-br_table-value\" (func 52)) + (export \"nested-br_table-value-index\" (func 53)) + (elem (;0;) (i32.const 0) 36)) + "; + 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 334 +fn c1_l334_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l334_action_invoke"); + let result = instance.call("type-i32", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 335 +fn c2_l335_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l335_action_invoke"); + let result = instance.call("type-i64", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 336 +fn c3_l336_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l336_action_invoke"); + let result = instance.call("type-f32", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 337 +fn c4_l337_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l337_action_invoke"); + let result = instance.call("type-f64", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 339 +fn c5_l339_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l339_action_invoke"); + let result = instance.call("type-i32-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 340 +fn c6_l340_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l340_action_invoke"); + let result = instance.call("type-i64-value", &[]); + assert_eq!(result, Ok(Some(Value::I64(2 as i64)))); + result.map(|_| ()) +} + +// Line 341 +fn c7_l341_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l341_action_invoke"); + let result = instance.call("type-f32-value", &[]); + assert_eq!(result, Ok(Some(Value::F32((3.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 342 +fn c8_l342_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l342_action_invoke"); + let result = instance.call("type-f64-value", &[]); + assert_eq!(result, Ok(Some(Value::F64((4.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 344 +fn c9_l344_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l344_action_invoke"); + let result = instance.call("as-block-first", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 345 +fn c10_l345_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c10_l345_action_invoke"); + let result = instance.call("as-block-first", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 346 +fn c11_l346_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c11_l346_action_invoke"); + let result = instance.call("as-block-mid", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 347 +fn c12_l347_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c12_l347_action_invoke"); + let result = instance.call("as-block-mid", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 348 +fn c13_l348_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c13_l348_action_invoke"); + let result = instance.call("as-block-last", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 349 +fn c14_l349_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c14_l349_action_invoke"); + let result = instance.call("as-block-last", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 351 +fn c15_l351_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c15_l351_action_invoke"); + let result = instance.call("as-block-first-value", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(11 as i32)))); + result.map(|_| ()) +} + +// Line 352 +fn c16_l352_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c16_l352_action_invoke"); + let result = instance.call("as-block-first-value", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); + result.map(|_| ()) +} + +// Line 353 +fn c17_l353_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c17_l353_action_invoke"); + let result = instance.call("as-block-mid-value", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(21 as i32)))); + result.map(|_| ()) +} + +// Line 354 +fn c18_l354_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c18_l354_action_invoke"); + let result = instance.call("as-block-mid-value", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(20 as i32)))); + result.map(|_| ()) +} + +// Line 355 +fn c19_l355_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c19_l355_action_invoke"); + let result = instance.call("as-block-last-value", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(11 as i32)))); + result.map(|_| ()) +} + +// Line 356 +fn c20_l356_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c20_l356_action_invoke"); + let result = instance.call("as-block-last-value", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(11 as i32)))); + result.map(|_| ()) +} + +// Line 358 +fn c21_l358_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c21_l358_action_invoke"); + let result = instance.call("as-loop-first", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 359 +fn c22_l359_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c22_l359_action_invoke"); + let result = instance.call("as-loop-first", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 360 +fn c23_l360_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c23_l360_action_invoke"); + let result = instance.call("as-loop-mid", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 361 +fn c24_l361_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c24_l361_action_invoke"); + let result = instance.call("as-loop-mid", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(4 as i32)))); + result.map(|_| ()) +} + +// Line 362 +fn c25_l362_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c25_l362_action_invoke"); + let result = instance.call("as-loop-last", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 363 +fn c26_l363_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c26_l363_action_invoke"); + let result = instance.call("as-loop-last", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 365 +fn c27_l365_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c27_l365_action_invoke"); + let result = instance.call("as-br-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 367 +fn c28_l367_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c28_l367_action_invoke"); + let result = instance.call("as-br_if-cond", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 368 +fn c29_l368_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c29_l368_action_invoke"); + let result = instance.call("as-br_if-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 369 +fn c30_l369_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c30_l369_action_invoke"); + let result = instance.call("as-br_if-value-cond", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 370 +fn c31_l370_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c31_l370_action_invoke"); + let result = instance.call("as-br_if-value-cond", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 372 +fn c32_l372_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c32_l372_action_invoke"); + let result = instance.call("as-br_table-index", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 373 +fn c33_l373_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c33_l373_action_invoke"); + let result = instance.call("as-br_table-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 374 +fn c34_l374_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c34_l374_action_invoke"); + let result = instance.call("as-br_table-value-index", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 376 +fn c35_l376_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c35_l376_action_invoke"); + let result = instance.call("as-return-value", &[]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 378 +fn c36_l378_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c36_l378_action_invoke"); + let result = instance.call("as-if-cond", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 379 +fn c37_l379_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c37_l379_action_invoke"); + let result = instance.call("as-if-cond", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 380 +fn c38_l380_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c38_l380_action_invoke"); + let result = instance.call("as-if-then", &[Value::I32(0 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 381 +fn c39_l381_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c39_l381_action_invoke"); + let result = instance.call("as-if-then", &[Value::I32(4 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 382 +fn c40_l382_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c40_l382_action_invoke"); + let result = instance.call("as-if-then", &[Value::I32(0 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 383 +fn c41_l383_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c41_l383_action_invoke"); + let result = instance.call("as-if-then", &[Value::I32(4 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 384 +fn c42_l384_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c42_l384_action_invoke"); + let result = instance.call("as-if-else", &[Value::I32(0 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 385 +fn c43_l385_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c43_l385_action_invoke"); + let result = instance.call("as-if-else", &[Value::I32(3 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 386 +fn c44_l386_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c44_l386_action_invoke"); + let result = instance.call("as-if-else", &[Value::I32(0 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 387 +fn c45_l387_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c45_l387_action_invoke"); + let result = instance.call("as-if-else", &[Value::I32(3 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 389 +fn c46_l389_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c46_l389_action_invoke"); + let result = instance.call("as-select-first", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 390 +fn c47_l390_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c47_l390_action_invoke"); + let result = instance.call("as-select-first", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 391 +fn c48_l391_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c48_l391_action_invoke"); + let result = instance.call("as-select-second", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 392 +fn c49_l392_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c49_l392_action_invoke"); + let result = instance.call("as-select-second", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 393 +fn c50_l393_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c50_l393_action_invoke"); + let result = instance.call("as-select-cond", &[]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 395 +fn c51_l395_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c51_l395_action_invoke"); + let result = instance.call("as-call-first", &[]); + assert_eq!(result, Ok(Some(Value::I32(12 as i32)))); + result.map(|_| ()) +} + +// Line 396 +fn c52_l396_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c52_l396_action_invoke"); + let result = instance.call("as-call-mid", &[]); + assert_eq!(result, Ok(Some(Value::I32(13 as i32)))); + result.map(|_| ()) +} + +// Line 397 +fn c53_l397_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c53_l397_action_invoke"); + let result = instance.call("as-call-last", &[]); + assert_eq!(result, Ok(Some(Value::I32(14 as i32)))); + result.map(|_| ()) +} + +// Line 399 +fn c54_l399_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c54_l399_action_invoke"); + let result = instance.call("as-call_indirect-func", &[]); + assert_eq!(result, Ok(Some(Value::I32(4 as i32)))); + result.map(|_| ()) +} + +// Line 400 +fn c55_l400_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c55_l400_action_invoke"); + let result = instance.call("as-call_indirect-first", &[]); + assert_eq!(result, Ok(Some(Value::I32(4 as i32)))); + result.map(|_| ()) +} + +// Line 401 +fn c56_l401_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c56_l401_action_invoke"); + let result = instance.call("as-call_indirect-mid", &[]); + assert_eq!(result, Ok(Some(Value::I32(4 as i32)))); + result.map(|_| ()) +} + +// Line 402 +fn c57_l402_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c57_l402_action_invoke"); + let result = instance.call("as-call_indirect-last", &[]); + assert_eq!(result, Ok(Some(Value::I32(4 as i32)))); + result.map(|_| ()) +} + +// Line 404 +fn c58_l404_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c58_l404_action_invoke"); + let result = instance.call("as-set_local-value", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 405 +fn c59_l405_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c59_l405_action_invoke"); + let result = instance.call("as-set_local-value", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(17 as i32)))); + result.map(|_| ()) +} + +// Line 407 +fn c60_l407_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c60_l407_action_invoke"); + let result = instance.call("as-tee_local-value", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 408 +fn c61_l408_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c61_l408_action_invoke"); + let result = instance.call("as-tee_local-value", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 410 +fn c62_l410_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c62_l410_action_invoke"); + let result = instance.call("as-set_global-value", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 411 +fn c63_l411_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c63_l411_action_invoke"); + let result = instance.call("as-set_global-value", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 413 +fn c64_l413_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c64_l413_action_invoke"); + let result = instance.call("as-unary-operand", &[]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 414 +fn c65_l414_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c65_l414_action_invoke"); + let result = instance.call("as-binary-left", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 415 +fn c66_l415_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c66_l415_action_invoke"); + let result = instance.call("as-binary-right", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 416 +fn c67_l416_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c67_l416_action_invoke"); + let result = instance.call("as-memory.grow-size", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 418 +fn c68_l418_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c68_l418_action_invoke"); + let result = instance.call("nested-block-value", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(21 as i32)))); + result.map(|_| ()) +} + +// Line 419 +fn c69_l419_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c69_l419_action_invoke"); + let result = instance.call("nested-block-value", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 420 +fn c70_l420_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c70_l420_action_invoke"); + let result = instance.call("nested-br-value", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(5 as i32)))); + result.map(|_| ()) +} + +// Line 421 +fn c71_l421_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c71_l421_action_invoke"); + let result = instance.call("nested-br-value", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 422 +fn c72_l422_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c72_l422_action_invoke"); + let result = instance.call("nested-br_if-value", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(5 as i32)))); + result.map(|_| ()) +} + +// Line 423 +fn c73_l423_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c73_l423_action_invoke"); + let result = instance.call("nested-br_if-value", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 424 +fn c74_l424_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c74_l424_action_invoke"); + let result = instance.call("nested-br_if-value-cond", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(5 as i32)))); + result.map(|_| ()) +} + +// Line 425 +fn c75_l425_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c75_l425_action_invoke"); + let result = instance.call("nested-br_if-value-cond", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 426 +fn c76_l426_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c76_l426_action_invoke"); + let result = instance.call("nested-br_table-value", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(5 as i32)))); + result.map(|_| ()) +} + +// Line 427 +fn c77_l427_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c77_l427_action_invoke"); + let result = instance.call("nested-br_table-value", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 428 +fn c78_l428_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c78_l428_action_invoke"); + let result = instance.call("nested-br_table-value-index", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(5 as i32)))); + result.map(|_| ()) +} + +// Line 429 +fn c79_l429_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c79_l429_action_invoke"); + let result = instance.call("nested-br_table-value-index", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 432 +#[test] +fn c80_l432_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 65, 0, 13, 0, 104, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 436 +#[test] +fn c81_l436_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 65, 0, 13, 0, 122, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 440 +#[test] +fn c82_l440_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 65, 0, 13, 0, 140, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 444 +#[test] +fn c83_l444_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 65, 0, 13, 0, 154, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 449 +#[test] +fn c84_l449_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 65, 1, 13, 0, 104, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 453 +#[test] +fn c85_l453_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 66, 1, 13, 0, 122, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 457 +#[test] +fn c86_l457_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 64, 67, 0, 0, 128, 63, 13, 0, 140, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 461 +#[test] +fn c87_l461_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 66, 1, 13, 0, 154, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 466 +#[test] +fn c88_l466_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 127, 65, 0, 13, 0, 65, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 472 +#[test] +fn c89_l472_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 127, 65, 1, 13, 0, 65, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 478 +#[test] +fn c90_l478_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 64, 65, 0, 65, 0, 13, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 484 +#[test] +fn c91_l484_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 64, 65, 0, 65, 1, 13, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 491 +#[test] +fn c92_l491_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 127, 1, 65, 0, 13, 0, 65, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 497 +#[test] +fn c93_l497_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 127, 1, 65, 1, 13, 0, 65, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 503 +#[test] +fn c94_l503_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 127, 66, 1, 65, 0, 13, 0, 26, 65, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 511 +#[test] +fn c95_l511_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 127, 66, 1, 65, 0, 13, 0, 26, 65, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 520 +#[test] +fn c96_l520_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 10, 1, 8, 0, 2, 64, 1, 13, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 526 +#[test] +fn c97_l526_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 64, 66, 0, 13, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 532 +#[test] +fn c98_l532_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 127, 65, 0, 1, 13, 0, 65, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 538 +#[test] +fn c99_l538_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 127, 65, 0, 2, 64, 65, 1, 13, 1, 11, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 544 +#[test] +fn c100_l544_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 127, 65, 0, 66, 0, 13, 0, 65, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 551 +#[test] +fn c101_l551_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 8, 1, 6, 0, 65, 1, 13, 1, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 555 +#[test] +fn c102_l555_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 64, 2, 64, 65, 1, 13, 5, 11, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 559 +#[test] +fn c103_l559_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 1, 13, 129, 128, 128, 128, 1, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l334_action_invoke(&mut instance); + c2_l335_action_invoke(&mut instance); + c3_l336_action_invoke(&mut instance); + c4_l337_action_invoke(&mut instance); + c5_l339_action_invoke(&mut instance); + c6_l340_action_invoke(&mut instance); + c7_l341_action_invoke(&mut instance); + c8_l342_action_invoke(&mut instance); + c9_l344_action_invoke(&mut instance); + c10_l345_action_invoke(&mut instance); + c11_l346_action_invoke(&mut instance); + c12_l347_action_invoke(&mut instance); + c13_l348_action_invoke(&mut instance); + c14_l349_action_invoke(&mut instance); + c15_l351_action_invoke(&mut instance); + c16_l352_action_invoke(&mut instance); + c17_l353_action_invoke(&mut instance); + c18_l354_action_invoke(&mut instance); + c19_l355_action_invoke(&mut instance); + c20_l356_action_invoke(&mut instance); + c21_l358_action_invoke(&mut instance); + c22_l359_action_invoke(&mut instance); + c23_l360_action_invoke(&mut instance); + c24_l361_action_invoke(&mut instance); + c25_l362_action_invoke(&mut instance); + c26_l363_action_invoke(&mut instance); + c27_l365_action_invoke(&mut instance); + c28_l367_action_invoke(&mut instance); + c29_l368_action_invoke(&mut instance); + c30_l369_action_invoke(&mut instance); + c31_l370_action_invoke(&mut instance); + c32_l372_action_invoke(&mut instance); + c33_l373_action_invoke(&mut instance); + c34_l374_action_invoke(&mut instance); + c35_l376_action_invoke(&mut instance); + c36_l378_action_invoke(&mut instance); + c37_l379_action_invoke(&mut instance); + c38_l380_action_invoke(&mut instance); + c39_l381_action_invoke(&mut instance); + c40_l382_action_invoke(&mut instance); + c41_l383_action_invoke(&mut instance); + c42_l384_action_invoke(&mut instance); + c43_l385_action_invoke(&mut instance); + c44_l386_action_invoke(&mut instance); + c45_l387_action_invoke(&mut instance); + c46_l389_action_invoke(&mut instance); + c47_l390_action_invoke(&mut instance); + c48_l391_action_invoke(&mut instance); + c49_l392_action_invoke(&mut instance); + c50_l393_action_invoke(&mut instance); + c51_l395_action_invoke(&mut instance); + c52_l396_action_invoke(&mut instance); + c53_l397_action_invoke(&mut instance); + c54_l399_action_invoke(&mut instance); + c55_l400_action_invoke(&mut instance); + c56_l401_action_invoke(&mut instance); + c57_l402_action_invoke(&mut instance); + c58_l404_action_invoke(&mut instance); + c59_l405_action_invoke(&mut instance); + c60_l407_action_invoke(&mut instance); + c61_l408_action_invoke(&mut instance); + c62_l410_action_invoke(&mut instance); + c63_l411_action_invoke(&mut instance); + c64_l413_action_invoke(&mut instance); + c65_l414_action_invoke(&mut instance); + c66_l415_action_invoke(&mut instance); + c67_l416_action_invoke(&mut instance); + c68_l418_action_invoke(&mut instance); + c69_l419_action_invoke(&mut instance); + c70_l420_action_invoke(&mut instance); + c71_l421_action_invoke(&mut instance); + c72_l422_action_invoke(&mut instance); + c73_l423_action_invoke(&mut instance); + c74_l424_action_invoke(&mut instance); + c75_l425_action_invoke(&mut instance); + c76_l426_action_invoke(&mut instance); + c77_l427_action_invoke(&mut instance); + c78_l428_action_invoke(&mut instance); + c79_l429_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/br_table.rs b/lib/runtime/tests/spectests/br_table.rs new file mode 100644 index 000000000..336fb9530 --- /dev/null +++ b/lib/runtime/tests/spectests/br_table.rs @@ -0,0 +1,2238 @@ +// 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/br_table.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 3 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func (param i32 i32 i32) (result i32))) + (type (;1;) (func)) + (type (;2;) (func (result i32))) + (type (;3;) (func (result i64))) + (type (;4;) (func (result f32))) + (type (;5;) (func (result f64))) + (type (;6;) (func (param i32) (result i32))) + (type (;7;) (func (param i32 i32) (result i32))) + (func (;0;) (type 1)) + (func (;1;) (type 1) + block ;; label = @1 + i32.const 0 + br_table 0 (;@1;) 0 (;@1;) + i32.ctz + drop + end) + (func (;2;) (type 1) + block ;; label = @1 + i32.const 0 + br_table 0 (;@1;) 0 (;@1;) + i64.ctz + drop + end) + (func (;3;) (type 1) + block ;; label = @1 + i32.const 0 + br_table 0 (;@1;) 0 (;@1;) + f32.neg + drop + end) + (func (;4;) (type 1) + block ;; label = @1 + i32.const 0 + br_table 0 (;@1;) 0 (;@1;) + f64.neg + drop + end) + (func (;5;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + i32.const 0 + br_table 0 (;@1;) 0 (;@1;) + i32.ctz + end) + (func (;6;) (type 3) (result i64) + block (result i64) ;; label = @1 + i64.const 2 + i32.const 0 + br_table 0 (;@1;) 0 (;@1;) + i64.ctz + end) + (func (;7;) (type 4) (result f32) + block (result f32) ;; label = @1 + f32.const 0x1.8p+1 (;=3;) + i32.const 0 + br_table 0 (;@1;) 0 (;@1;) + f32.neg + end) + (func (;8;) (type 5) (result f64) + block (result f64) ;; label = @1 + f64.const 0x1p+2 (;=4;) + i32.const 0 + br_table 0 (;@1;) 0 (;@1;) + f64.neg + end) + (func (;9;) (type 6) (param i32) (result i32) + block ;; label = @1 + get_local 0 + br_table 0 (;@1;) + i32.const 21 + return + end + i32.const 22) + (func (;10;) (type 6) (param i32) (result i32) + block (result i32) ;; label = @1 + i32.const 33 + get_local 0 + br_table 0 (;@1;) + i32.const 31 + end) + (func (;11;) (type 6) (param i32) (result i32) + block ;; label = @1 + block ;; label = @2 + get_local 0 + br_table 1 (;@1;) 0 (;@2;) + i32.const 21 + return + end + i32.const 20 + return + end + i32.const 22) + (func (;12;) (type 6) (param i32) (result i32) + block (result i32) ;; label = @1 + block (result i32) ;; label = @2 + i32.const 33 + get_local 0 + br_table 0 (;@2;) 1 (;@1;) + i32.const 31 + return + end + drop + i32.const 32 + end) + (func (;13;) (type 6) (param i32) (result i32) + block ;; label = @1 + block ;; label = @2 + block ;; label = @3 + block ;; label = @4 + block ;; label = @5 + get_local 0 + br_table 3 (;@2;) 2 (;@3;) 1 (;@4;) 0 (;@5;) 4 (;@1;) + i32.const 99 + return + end + i32.const 100 + return + end + i32.const 101 + return + end + i32.const 102 + return + end + i32.const 103 + return + end + i32.const 104) + (func (;14;) (type 6) (param i32) (result i32) + (local i32) + block (result i32) ;; label = @1 + block (result i32) ;; label = @2 + block (result i32) ;; label = @3 + block (result i32) ;; label = @4 + block (result i32) ;; label = @5 + i32.const 200 + get_local 0 + br_table 3 (;@2;) 2 (;@3;) 1 (;@4;) 0 (;@5;) 4 (;@1;) + get_local 1 + i32.const 99 + i32.add + return + end + set_local 1 + get_local 1 + i32.const 10 + i32.add + return + end + set_local 1 + get_local 1 + i32.const 11 + i32.add + return + end + set_local 1 + get_local 1 + i32.const 12 + i32.add + return + end + set_local 1 + get_local 1 + i32.const 13 + i32.add + return + end + set_local 1 + get_local 1 + i32.const 14 + i32.add) + (func (;15;) (type 6) (param i32) (result i32) + block ;; label = @1 + block ;; label = @2 + get_local 0 + br_table 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) 0 (;@2;) 1 (;@1;) + i32.const -1 + return + end + i32.const 0 + return + end + i32.const 1 + return) + (func (;16;) (type 1) + block ;; label = @1 + i32.const 0 + br_table 0 (;@1;) 0 (;@1;) 0 (;@1;) + call 0 + end) + (func (;17;) (type 1) + block ;; label = @1 + call 0 + i32.const 0 + br_table 0 (;@1;) 0 (;@1;) 0 (;@1;) + call 0 + end) + (func (;18;) (type 1) + block ;; label = @1 + nop + call 0 + i32.const 0 + br_table 0 (;@1;) 0 (;@1;) 0 (;@1;) + end) + (func (;19;) (type 2) (result i32) + block (result i32) ;; label = @1 + nop + call 0 + i32.const 2 + i32.const 0 + br_table 0 (;@1;) 0 (;@1;) 0 (;@1;) + end) + (func (;20;) (type 2) (result i32) + loop (result i32) ;; label = @1 + i32.const 3 + i32.const 0 + br_table 1 (;@0;) 1 (;@0;) + i32.const 1 + end) + (func (;21;) (type 2) (result i32) + loop (result i32) ;; label = @1 + call 0 + i32.const 4 + i32.const -1 + br_table 1 (;@0;) 1 (;@0;) 1 (;@0;) + i32.const 2 + end) + (func (;22;) (type 2) (result i32) + loop (result i32) ;; label = @1 + nop + call 0 + i32.const 5 + i32.const 1 + br_table 1 (;@0;) 1 (;@0;) 1 (;@0;) + end) + (func (;23;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 9 + i32.const 0 + br_table 0 (;@1;) + br 0 (;@1;) + end) + (func (;24;) (type 1) + block ;; label = @1 + i32.const 1 + br_table 0 (;@1;) 0 (;@1;) 0 (;@1;) + br_if 0 (;@1;) + end) + (func (;25;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 8 + i32.const 0 + br_table 0 (;@1;) + i32.const 1 + br_if 0 (;@1;) + drop + i32.const 7 + end) + (func (;26;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 6 + i32.const 9 + i32.const 0 + br_table 0 (;@1;) 0 (;@1;) + br_if 0 (;@1;) + drop + i32.const 7 + end) + (func (;27;) (type 1) + block ;; label = @1 + i32.const 1 + br_table 0 (;@1;) + br_table 0 (;@1;) 0 (;@1;) 0 (;@1;) + end) + (func (;28;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 10 + i32.const 0 + br_table 0 (;@1;) + i32.const 1 + br_table 0 (;@1;) 0 (;@1;) 0 (;@1;) + i32.const 7 + end) + (func (;29;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 6 + i32.const 11 + i32.const 1 + br_table 0 (;@1;) + br_table 0 (;@1;) 0 (;@1;) + i32.const 7 + end) + (func (;30;) (type 3) (result i64) + block (result i64) ;; label = @1 + i64.const 7 + i32.const 0 + br_table 0 (;@1;) + return + end) + (func (;31;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 2 + i32.const 0 + br_table 0 (;@1;) + if (result i32) ;; label = @2 + i32.const 0 + else + i32.const 1 + end + end) + (func (;32;) (type 7) (param i32 i32) (result i32) + block (result i32) ;; label = @1 + get_local 0 + if (result i32) ;; label = @2 + i32.const 3 + i32.const 0 + br_table 1 (;@1;) + else + get_local 1 + end + end) + (func (;33;) (type 7) (param i32 i32) (result i32) + block (result i32) ;; label = @1 + get_local 0 + if (result i32) ;; label = @2 + get_local 1 + else + i32.const 4 + i32.const 0 + br_table 1 (;@1;) 0 (;@2;) + end + end) + (func (;34;) (type 7) (param i32 i32) (result i32) + block (result i32) ;; label = @1 + i32.const 5 + i32.const 0 + br_table 0 (;@1;) + get_local 0 + get_local 1 + select + end) + (func (;35;) (type 7) (param i32 i32) (result i32) + block (result i32) ;; label = @1 + get_local 0 + i32.const 6 + i32.const 1 + br_table 0 (;@1;) + get_local 1 + select + end) + (func (;36;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 0 + i32.const 1 + i32.const 7 + i32.const 1 + br_table 0 (;@1;) + select + end) + (func (;37;) (type 0) (param i32 i32 i32) (result i32) + i32.const -1) + (func (;38;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 12 + i32.const 1 + br_table 0 (;@1;) + i32.const 2 + i32.const 3 + call 37 + end) + (func (;39;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + i32.const 13 + i32.const 1 + br_table 0 (;@1;) + i32.const 3 + call 37 + end) + (func (;40;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + i32.const 2 + i32.const 14 + i32.const 1 + br_table 0 (;@1;) + call 37 + end) + (func (;41;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 20 + i32.const 1 + br_table 0 (;@1;) + i32.const 1 + i32.const 2 + i32.const 3 + call_indirect (type 0) + end) + (func (;42;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 0 + i32.const 21 + i32.const 1 + br_table 0 (;@1;) + i32.const 2 + i32.const 3 + call_indirect (type 0) + end) + (func (;43;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 0 + i32.const 1 + i32.const 22 + i32.const 1 + br_table 0 (;@1;) + i32.const 3 + call_indirect (type 0) + end) + (func (;44;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 0 + i32.const 1 + i32.const 2 + i32.const 23 + i32.const 1 + br_table 0 (;@1;) + call_indirect (type 0) + end) + (func (;45;) (type 2) (result i32) + (local f32) + block (result i32) ;; label = @1 + i32.const 17 + i32.const 1 + br_table 0 (;@1;) + set_local 0 + i32.const -1 + end) + (func (;46;) (type 2) (result i32) + (local i32) + block (result i32) ;; label = @1 + i32.const 1 + i32.const 1 + br_table 0 (;@1;) + set_local 0 + i32.const -1 + end) + (func (;47;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + i32.const 1 + br_table 0 (;@1;) + set_global 0 + i32.const -1 + end) + (func (;48;) (type 4) (result f32) + block (result f32) ;; label = @1 + f32.const 0x1.b33334p+0 (;=1.7;) + i32.const 1 + br_table 0 (;@1;) + f32.load + end) + (func (;49;) (type 3) (result i64) + block (result i64) ;; label = @1 + i64.const 30 + i32.const 1 + br_table 0 (;@1;) + i64.load8_s + end) + (func (;50;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 30 + i32.const 1 + br_table 0 (;@1;) + f64.const 0x1.cp+2 (;=7;) + f64.store + i32.const -1 + end) + (func (;51;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 2 + i32.const 31 + i32.const 1 + br_table 0 (;@1;) + i64.store + i32.const -1 + end) + (func (;52;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 32 + i32.const 0 + br_table 0 (;@1;) + i32.const 7 + i32.store8 + i32.const -1 + end) + (func (;53;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 2 + i32.const 33 + i32.const 0 + br_table 0 (;@1;) + i64.store16 + i32.const -1 + end) + (func (;54;) (type 4) (result f32) + block (result f32) ;; label = @1 + f32.const 0x1.b33334p+1 (;=3.4;) + i32.const 0 + br_table 0 (;@1;) + f32.neg + end) + (func (;55;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 3 + i32.const 0 + br_table 0 (;@1;) 0 (;@1;) + i32.const 10 + i32.add + end) + (func (;56;) (type 3) (result i64) + block (result i64) ;; label = @1 + i64.const 10 + i64.const 45 + i32.const 0 + br_table 0 (;@1;) + i64.sub + end) + (func (;57;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 44 + i32.const 0 + br_table 0 (;@1;) + i32.eqz + end) + (func (;58;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 43 + i32.const 0 + br_table 0 (;@1;) 0 (;@1;) + f64.const 0x1.4p+3 (;=10;) + f64.le + end) + (func (;59;) (type 2) (result i32) + block (result i32) ;; label = @1 + f32.const 0x1.4p+3 (;=10;) + i32.const 42 + i32.const 0 + br_table 0 (;@1;) + f32.ne + end) + (func (;60;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 41 + i32.const 0 + br_table 0 (;@1;) + i32.wrap/i64 + end) + (func (;61;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 40 + i32.const 0 + br_table 0 (;@1;) + memory.grow + end) + (func (;62;) (type 6) (param i32) (result i32) + block (result i32) ;; label = @1 + i32.const -1 + drop + i32.const 1 + block (result i32) ;; label = @2 + i32.const 2 + block (result i32) ;; label = @3 + i32.const 4 + drop + i32.const 8 + i32.const 16 + get_local 0 + br_table 0 (;@3;) 1 (;@2;) 2 (;@1;) + i32.add + end + i32.add + end + i32.add + end) + (func (;63;) (type 6) (param i32) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + block (result i32) ;; label = @2 + i32.const 2 + drop + block (result i32) ;; label = @3 + i32.const 4 + drop + i32.const 8 + get_local 0 + br_table 2 (;@1;) 1 (;@2;) 0 (;@3;) + br 0 (;@3;) + end + drop + i32.const 16 + end + i32.add + end) + (func (;64;) (type 6) (param i32) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + block (result i32) ;; label = @2 + i32.const 2 + drop + block (result i32) ;; label = @3 + i32.const 4 + drop + i32.const 8 + get_local 0 + br_table 0 (;@3;) 1 (;@2;) 2 (;@1;) + i32.const 1 + br_if 0 (;@3;) + drop + i32.const 32 + end + drop + i32.const 16 + end + i32.add + end) + (func (;65;) (type 6) (param i32) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + block (result i32) ;; label = @2 + i32.const 2 + drop + i32.const 4 + i32.const 8 + get_local 0 + br_table 0 (;@2;) 1 (;@1;) 0 (;@2;) + br_if 0 (;@2;) + drop + i32.const 16 + end + i32.add + end) + (func (;66;) (type 6) (param i32) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + block (result i32) ;; label = @2 + i32.const 2 + drop + block (result i32) ;; label = @3 + i32.const 4 + drop + i32.const 8 + get_local 0 + br_table 0 (;@3;) 1 (;@2;) 2 (;@1;) + i32.const 1 + br_table 0 (;@3;) + i32.const 32 + end + drop + i32.const 16 + end + i32.add + end) + (func (;67;) (type 6) (param i32) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + block (result i32) ;; label = @2 + i32.const 2 + drop + i32.const 4 + i32.const 8 + get_local 0 + br_table 0 (;@2;) 1 (;@1;) 0 (;@2;) + br_table 0 (;@2;) + i32.const 16 + end + i32.add + end) + (func (;68;) (type 6) (param i32) (result i32) + loop (result i32) ;; label = @1 + block ;; label = @2 + get_local 0 + br_table 1 (;@1;) 0 (;@2;) 0 (;@2;) + end + i32.const 0 + end + set_local 0 + loop (result i32) ;; label = @1 + block ;; label = @2 + get_local 0 + br_table 0 (;@2;) 1 (;@1;) 1 (;@1;) + end + i32.const 3 + end) + (table (;0;) 1 1 anyfunc) + (memory (;0;) 1) + (global (;0;) (mut i32) (i32.const 10)) + (export \"type-i32\" (func 1)) + (export \"type-i64\" (func 2)) + (export \"type-f32\" (func 3)) + (export \"type-f64\" (func 4)) + (export \"type-i32-value\" (func 5)) + (export \"type-i64-value\" (func 6)) + (export \"type-f32-value\" (func 7)) + (export \"type-f64-value\" (func 8)) + (export \"empty\" (func 9)) + (export \"empty-value\" (func 10)) + (export \"singleton\" (func 11)) + (export \"singleton-value\" (func 12)) + (export \"multiple\" (func 13)) + (export \"multiple-value\" (func 14)) + (export \"large\" (func 15)) + (export \"as-block-first\" (func 16)) + (export \"as-block-mid\" (func 17)) + (export \"as-block-last\" (func 18)) + (export \"as-block-value\" (func 19)) + (export \"as-loop-first\" (func 20)) + (export \"as-loop-mid\" (func 21)) + (export \"as-loop-last\" (func 22)) + (export \"as-br-value\" (func 23)) + (export \"as-br_if-cond\" (func 24)) + (export \"as-br_if-value\" (func 25)) + (export \"as-br_if-value-cond\" (func 26)) + (export \"as-br_table-index\" (func 27)) + (export \"as-br_table-value\" (func 28)) + (export \"as-br_table-value-index\" (func 29)) + (export \"as-return-value\" (func 30)) + (export \"as-if-cond\" (func 31)) + (export \"as-if-then\" (func 32)) + (export \"as-if-else\" (func 33)) + (export \"as-select-first\" (func 34)) + (export \"as-select-second\" (func 35)) + (export \"as-select-cond\" (func 36)) + (export \"as-call-first\" (func 38)) + (export \"as-call-mid\" (func 39)) + (export \"as-call-last\" (func 40)) + (export \"as-call_indirect-first\" (func 41)) + (export \"as-call_indirect-mid\" (func 42)) + (export \"as-call_indirect-last\" (func 43)) + (export \"as-call_indirect-func\" (func 44)) + (export \"as-set_local-value\" (func 45)) + (export \"as-tee_local-value\" (func 46)) + (export \"as-set_global-value\" (func 47)) + (export \"as-load-address\" (func 48)) + (export \"as-loadN-address\" (func 49)) + (export \"as-store-address\" (func 50)) + (export \"as-store-value\" (func 51)) + (export \"as-storeN-address\" (func 52)) + (export \"as-storeN-value\" (func 53)) + (export \"as-unary-operand\" (func 54)) + (export \"as-binary-left\" (func 55)) + (export \"as-binary-right\" (func 56)) + (export \"as-test-operand\" (func 57)) + (export \"as-compare-left\" (func 58)) + (export \"as-compare-right\" (func 59)) + (export \"as-convert-operand\" (func 60)) + (export \"as-memory.grow-size\" (func 61)) + (export \"nested-block-value\" (func 62)) + (export \"nested-br-value\" (func 63)) + (export \"nested-br_if-value\" (func 64)) + (export \"nested-br_if-value-cond\" (func 65)) + (export \"nested-br_table-value\" (func 66)) + (export \"nested-br_table-value-index\" (func 67)) + (export \"nested-br_table-loop-block\" (func 68)) + (elem (;0;) (i32.const 0) 37)) + "; + 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 1247 +fn c1_l1247_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l1247_action_invoke"); + let result = instance.call("type-i32", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 1248 +fn c2_l1248_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l1248_action_invoke"); + let result = instance.call("type-i64", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 1249 +fn c3_l1249_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l1249_action_invoke"); + let result = instance.call("type-f32", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 1250 +fn c4_l1250_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l1250_action_invoke"); + let result = instance.call("type-f64", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 1252 +fn c5_l1252_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l1252_action_invoke"); + let result = instance.call("type-i32-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1253 +fn c6_l1253_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l1253_action_invoke"); + let result = instance.call("type-i64-value", &[]); + assert_eq!(result, Ok(Some(Value::I64(2 as i64)))); + result.map(|_| ()) +} + +// Line 1254 +fn c7_l1254_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l1254_action_invoke"); + let result = instance.call("type-f32-value", &[]); + assert_eq!(result, Ok(Some(Value::F32((3.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1255 +fn c8_l1255_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l1255_action_invoke"); + let result = instance.call("type-f64-value", &[]); + assert_eq!(result, Ok(Some(Value::F64((4.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1257 +fn c9_l1257_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l1257_action_invoke"); + let result = instance.call("empty", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(22 as i32)))); + result.map(|_| ()) +} + +// Line 1258 +fn c10_l1258_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c10_l1258_action_invoke"); + let result = instance.call("empty", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(22 as i32)))); + result.map(|_| ()) +} + +// Line 1259 +fn c11_l1259_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c11_l1259_action_invoke"); + let result = instance.call("empty", &[Value::I32(11 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(22 as i32)))); + result.map(|_| ()) +} + +// Line 1260 +fn c12_l1260_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c12_l1260_action_invoke"); + let result = instance.call("empty", &[Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(22 as i32)))); + result.map(|_| ()) +} + +// Line 1261 +fn c13_l1261_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c13_l1261_action_invoke"); + let result = instance.call("empty", &[Value::I32(-100 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(22 as i32)))); + result.map(|_| ()) +} + +// Line 1262 +fn c14_l1262_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c14_l1262_action_invoke"); + let result = instance.call("empty", &[Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(22 as i32)))); + result.map(|_| ()) +} + +// Line 1264 +fn c15_l1264_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c15_l1264_action_invoke"); + let result = instance.call("empty-value", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(33 as i32)))); + result.map(|_| ()) +} + +// Line 1265 +fn c16_l1265_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c16_l1265_action_invoke"); + let result = instance.call("empty-value", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(33 as i32)))); + result.map(|_| ()) +} + +// Line 1266 +fn c17_l1266_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c17_l1266_action_invoke"); + let result = instance.call("empty-value", &[Value::I32(11 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(33 as i32)))); + result.map(|_| ()) +} + +// Line 1267 +fn c18_l1267_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c18_l1267_action_invoke"); + let result = instance.call("empty-value", &[Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(33 as i32)))); + result.map(|_| ()) +} + +// Line 1268 +fn c19_l1268_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c19_l1268_action_invoke"); + let result = instance.call("empty-value", &[Value::I32(-100 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(33 as i32)))); + result.map(|_| ()) +} + +// Line 1269 +fn c20_l1269_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c20_l1269_action_invoke"); + let result = instance.call("empty-value", &[Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(33 as i32)))); + result.map(|_| ()) +} + +// Line 1271 +fn c21_l1271_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c21_l1271_action_invoke"); + let result = instance.call("singleton", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(22 as i32)))); + result.map(|_| ()) +} + +// Line 1272 +fn c22_l1272_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c22_l1272_action_invoke"); + let result = instance.call("singleton", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(20 as i32)))); + result.map(|_| ()) +} + +// Line 1273 +fn c23_l1273_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c23_l1273_action_invoke"); + let result = instance.call("singleton", &[Value::I32(11 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(20 as i32)))); + result.map(|_| ()) +} + +// Line 1274 +fn c24_l1274_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c24_l1274_action_invoke"); + let result = instance.call("singleton", &[Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(20 as i32)))); + result.map(|_| ()) +} + +// Line 1275 +fn c25_l1275_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c25_l1275_action_invoke"); + let result = instance.call("singleton", &[Value::I32(-100 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(20 as i32)))); + result.map(|_| ()) +} + +// Line 1276 +fn c26_l1276_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c26_l1276_action_invoke"); + let result = instance.call("singleton", &[Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(20 as i32)))); + result.map(|_| ()) +} + +// Line 1278 +fn c27_l1278_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c27_l1278_action_invoke"); + let result = instance.call("singleton-value", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(32 as i32)))); + result.map(|_| ()) +} + +// Line 1279 +fn c28_l1279_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c28_l1279_action_invoke"); + let result = instance.call("singleton-value", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(33 as i32)))); + result.map(|_| ()) +} + +// Line 1280 +fn c29_l1280_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c29_l1280_action_invoke"); + let result = instance.call("singleton-value", &[Value::I32(11 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(33 as i32)))); + result.map(|_| ()) +} + +// Line 1281 +fn c30_l1281_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c30_l1281_action_invoke"); + let result = instance.call("singleton-value", &[Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(33 as i32)))); + result.map(|_| ()) +} + +// Line 1282 +fn c31_l1282_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c31_l1282_action_invoke"); + let result = instance.call("singleton-value", &[Value::I32(-100 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(33 as i32)))); + result.map(|_| ()) +} + +// Line 1283 +fn c32_l1283_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c32_l1283_action_invoke"); + let result = instance.call("singleton-value", &[Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(33 as i32)))); + result.map(|_| ()) +} + +// Line 1285 +fn c33_l1285_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c33_l1285_action_invoke"); + let result = instance.call("multiple", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(103 as i32)))); + result.map(|_| ()) +} + +// Line 1286 +fn c34_l1286_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c34_l1286_action_invoke"); + let result = instance.call("multiple", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(102 as i32)))); + result.map(|_| ()) +} + +// Line 1287 +fn c35_l1287_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c35_l1287_action_invoke"); + let result = instance.call("multiple", &[Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(101 as i32)))); + result.map(|_| ()) +} + +// Line 1288 +fn c36_l1288_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c36_l1288_action_invoke"); + let result = instance.call("multiple", &[Value::I32(3 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(100 as i32)))); + result.map(|_| ()) +} + +// Line 1289 +fn c37_l1289_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c37_l1289_action_invoke"); + let result = instance.call("multiple", &[Value::I32(4 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(104 as i32)))); + result.map(|_| ()) +} + +// Line 1290 +fn c38_l1290_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c38_l1290_action_invoke"); + let result = instance.call("multiple", &[Value::I32(5 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(104 as i32)))); + result.map(|_| ()) +} + +// Line 1291 +fn c39_l1291_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c39_l1291_action_invoke"); + let result = instance.call("multiple", &[Value::I32(6 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(104 as i32)))); + result.map(|_| ()) +} + +// Line 1292 +fn c40_l1292_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c40_l1292_action_invoke"); + let result = instance.call("multiple", &[Value::I32(10 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(104 as i32)))); + result.map(|_| ()) +} + +// Line 1293 +fn c41_l1293_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c41_l1293_action_invoke"); + let result = instance.call("multiple", &[Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(104 as i32)))); + result.map(|_| ()) +} + +// Line 1294 +fn c42_l1294_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c42_l1294_action_invoke"); + let result = instance.call("multiple", &[Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(104 as i32)))); + result.map(|_| ()) +} + +// Line 1296 +fn c43_l1296_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c43_l1296_action_invoke"); + let result = instance.call("multiple-value", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(213 as i32)))); + result.map(|_| ()) +} + +// Line 1297 +fn c44_l1297_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c44_l1297_action_invoke"); + let result = instance.call("multiple-value", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(212 as i32)))); + result.map(|_| ()) +} + +// Line 1298 +fn c45_l1298_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c45_l1298_action_invoke"); + let result = instance.call("multiple-value", &[Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(211 as i32)))); + result.map(|_| ()) +} + +// Line 1299 +fn c46_l1299_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c46_l1299_action_invoke"); + let result = instance.call("multiple-value", &[Value::I32(3 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(210 as i32)))); + result.map(|_| ()) +} + +// Line 1300 +fn c47_l1300_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c47_l1300_action_invoke"); + let result = instance.call("multiple-value", &[Value::I32(4 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(214 as i32)))); + result.map(|_| ()) +} + +// Line 1301 +fn c48_l1301_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c48_l1301_action_invoke"); + let result = instance.call("multiple-value", &[Value::I32(5 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(214 as i32)))); + result.map(|_| ()) +} + +// Line 1302 +fn c49_l1302_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c49_l1302_action_invoke"); + let result = instance.call("multiple-value", &[Value::I32(6 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(214 as i32)))); + result.map(|_| ()) +} + +// Line 1303 +fn c50_l1303_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c50_l1303_action_invoke"); + let result = instance.call("multiple-value", &[Value::I32(10 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(214 as i32)))); + result.map(|_| ()) +} + +// Line 1304 +fn c51_l1304_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c51_l1304_action_invoke"); + let result = instance.call("multiple-value", &[Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(214 as i32)))); + result.map(|_| ()) +} + +// Line 1305 +fn c52_l1305_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c52_l1305_action_invoke"); + let result = instance.call("multiple-value", &[Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(214 as i32)))); + result.map(|_| ()) +} + +// Line 1307 +fn c53_l1307_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c53_l1307_action_invoke"); + let result = instance.call("large", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1308 +fn c54_l1308_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c54_l1308_action_invoke"); + let result = instance.call("large", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1309 +fn c55_l1309_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c55_l1309_action_invoke"); + let result = instance.call("large", &[Value::I32(100 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1310 +fn c56_l1310_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c56_l1310_action_invoke"); + let result = instance.call("large", &[Value::I32(101 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1311 +fn c57_l1311_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c57_l1311_action_invoke"); + let result = instance.call("large", &[Value::I32(10000 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1312 +fn c58_l1312_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c58_l1312_action_invoke"); + let result = instance.call("large", &[Value::I32(10001 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1313 +fn c59_l1313_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c59_l1313_action_invoke"); + let result = instance.call("large", &[Value::I32(1000000 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1314 +fn c60_l1314_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c60_l1314_action_invoke"); + let result = instance.call("large", &[Value::I32(1000001 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1316 +fn c61_l1316_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c61_l1316_action_invoke"); + let result = instance.call("as-block-first", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 1317 +fn c62_l1317_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c62_l1317_action_invoke"); + let result = instance.call("as-block-mid", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 1318 +fn c63_l1318_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c63_l1318_action_invoke"); + let result = instance.call("as-block-last", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 1319 +fn c64_l1319_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c64_l1319_action_invoke"); + let result = instance.call("as-block-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 1321 +fn c65_l1321_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c65_l1321_action_invoke"); + let result = instance.call("as-loop-first", &[]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 1322 +fn c66_l1322_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c66_l1322_action_invoke"); + let result = instance.call("as-loop-mid", &[]); + assert_eq!(result, Ok(Some(Value::I32(4 as i32)))); + result.map(|_| ()) +} + +// Line 1323 +fn c67_l1323_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c67_l1323_action_invoke"); + let result = instance.call("as-loop-last", &[]); + assert_eq!(result, Ok(Some(Value::I32(5 as i32)))); + result.map(|_| ()) +} + +// Line 1325 +fn c68_l1325_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c68_l1325_action_invoke"); + let result = instance.call("as-br-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 1327 +fn c69_l1327_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c69_l1327_action_invoke"); + let result = instance.call("as-br_if-cond", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 1328 +fn c70_l1328_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c70_l1328_action_invoke"); + let result = instance.call("as-br_if-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(8 as i32)))); + result.map(|_| ()) +} + +// Line 1329 +fn c71_l1329_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c71_l1329_action_invoke"); + let result = instance.call("as-br_if-value-cond", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 1331 +fn c72_l1331_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c72_l1331_action_invoke"); + let result = instance.call("as-br_table-index", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 1332 +fn c73_l1332_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c73_l1332_action_invoke"); + let result = instance.call("as-br_table-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); + result.map(|_| ()) +} + +// Line 1333 +fn c74_l1333_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c74_l1333_action_invoke"); + let result = instance.call("as-br_table-value-index", &[]); + assert_eq!(result, Ok(Some(Value::I32(11 as i32)))); + result.map(|_| ()) +} + +// Line 1335 +fn c75_l1335_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c75_l1335_action_invoke"); + let result = instance.call("as-return-value", &[]); + assert_eq!(result, Ok(Some(Value::I64(7 as i64)))); + result.map(|_| ()) +} + +// Line 1337 +fn c76_l1337_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c76_l1337_action_invoke"); + let result = instance.call("as-if-cond", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 1338 +fn c77_l1338_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c77_l1338_action_invoke"); + let result = instance.call("as-if-then", &[Value::I32(1 as i32), Value::I32(6 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 1339 +fn c78_l1339_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c78_l1339_action_invoke"); + let result = instance.call("as-if-then", &[Value::I32(0 as i32), Value::I32(6 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); + result.map(|_| ()) +} + +// Line 1340 +fn c79_l1340_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c79_l1340_action_invoke"); + let result = instance.call("as-if-else", &[Value::I32(0 as i32), Value::I32(6 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(4 as i32)))); + result.map(|_| ()) +} + +// Line 1341 +fn c80_l1341_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c80_l1341_action_invoke"); + let result = instance.call("as-if-else", &[Value::I32(1 as i32), Value::I32(6 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); + result.map(|_| ()) +} + +// Line 1343 +fn c81_l1343_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c81_l1343_action_invoke"); + let result = instance.call("as-select-first", &[Value::I32(0 as i32), Value::I32(6 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(5 as i32)))); + result.map(|_| ()) +} + +// Line 1344 +fn c82_l1344_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c82_l1344_action_invoke"); + let result = instance.call("as-select-first", &[Value::I32(1 as i32), Value::I32(6 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(5 as i32)))); + result.map(|_| ()) +} + +// Line 1345 +fn c83_l1345_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c83_l1345_action_invoke"); + let result = instance.call("as-select-second", &[Value::I32(0 as i32), Value::I32(6 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); + result.map(|_| ()) +} + +// Line 1346 +fn c84_l1346_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c84_l1346_action_invoke"); + let result = instance.call("as-select-second", &[Value::I32(1 as i32), Value::I32(6 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); + result.map(|_| ()) +} + +// Line 1347 +fn c85_l1347_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c85_l1347_action_invoke"); + let result = instance.call("as-select-cond", &[]); + assert_eq!(result, Ok(Some(Value::I32(7 as i32)))); + result.map(|_| ()) +} + +// Line 1349 +fn c86_l1349_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c86_l1349_action_invoke"); + let result = instance.call("as-call-first", &[]); + assert_eq!(result, Ok(Some(Value::I32(12 as i32)))); + result.map(|_| ()) +} + +// Line 1350 +fn c87_l1350_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c87_l1350_action_invoke"); + let result = instance.call("as-call-mid", &[]); + assert_eq!(result, Ok(Some(Value::I32(13 as i32)))); + result.map(|_| ()) +} + +// Line 1351 +fn c88_l1351_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c88_l1351_action_invoke"); + let result = instance.call("as-call-last", &[]); + assert_eq!(result, Ok(Some(Value::I32(14 as i32)))); + result.map(|_| ()) +} + +// Line 1353 +fn c89_l1353_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c89_l1353_action_invoke"); + let result = instance.call("as-call_indirect-first", &[]); + assert_eq!(result, Ok(Some(Value::I32(20 as i32)))); + result.map(|_| ()) +} + +// Line 1354 +fn c90_l1354_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c90_l1354_action_invoke"); + let result = instance.call("as-call_indirect-mid", &[]); + assert_eq!(result, Ok(Some(Value::I32(21 as i32)))); + result.map(|_| ()) +} + +// Line 1355 +fn c91_l1355_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c91_l1355_action_invoke"); + let result = instance.call("as-call_indirect-last", &[]); + assert_eq!(result, Ok(Some(Value::I32(22 as i32)))); + result.map(|_| ()) +} + +// Line 1356 +fn c92_l1356_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c92_l1356_action_invoke"); + let result = instance.call("as-call_indirect-func", &[]); + assert_eq!(result, Ok(Some(Value::I32(23 as i32)))); + result.map(|_| ()) +} + +// Line 1358 +fn c93_l1358_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c93_l1358_action_invoke"); + let result = instance.call("as-set_local-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(17 as i32)))); + result.map(|_| ()) +} + +// Line 1359 +fn c94_l1359_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c94_l1359_action_invoke"); + let result = instance.call("as-tee_local-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1360 +fn c95_l1360_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c95_l1360_action_invoke"); + let result = instance.call("as-set_global-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1362 +fn c96_l1362_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c96_l1362_action_invoke"); + let result = instance.call("as-load-address", &[]); + assert_eq!(result, Ok(Some(Value::F32((1.7f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1363 +fn c97_l1363_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c97_l1363_action_invoke"); + let result = instance.call("as-loadN-address", &[]); + assert_eq!(result, Ok(Some(Value::I64(30 as i64)))); + result.map(|_| ()) +} + +// Line 1365 +fn c98_l1365_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c98_l1365_action_invoke"); + let result = instance.call("as-store-address", &[]); + assert_eq!(result, Ok(Some(Value::I32(30 as i32)))); + result.map(|_| ()) +} + +// Line 1366 +fn c99_l1366_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c99_l1366_action_invoke"); + let result = instance.call("as-store-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(31 as i32)))); + result.map(|_| ()) +} + +// Line 1367 +fn c100_l1367_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c100_l1367_action_invoke"); + let result = instance.call("as-storeN-address", &[]); + assert_eq!(result, Ok(Some(Value::I32(32 as i32)))); + result.map(|_| ()) +} + +// Line 1368 +fn c101_l1368_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c101_l1368_action_invoke"); + let result = instance.call("as-storeN-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(33 as i32)))); + result.map(|_| ()) +} + +// Line 1370 +fn c102_l1370_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c102_l1370_action_invoke"); + let result = instance.call("as-unary-operand", &[]); + assert_eq!(result, Ok(Some(Value::F32((3.4f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1372 +fn c103_l1372_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c103_l1372_action_invoke"); + let result = instance.call("as-binary-left", &[]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 1373 +fn c104_l1373_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c104_l1373_action_invoke"); + let result = instance.call("as-binary-right", &[]); + assert_eq!(result, Ok(Some(Value::I64(45 as i64)))); + result.map(|_| ()) +} + +// Line 1375 +fn c105_l1375_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c105_l1375_action_invoke"); + let result = instance.call("as-test-operand", &[]); + assert_eq!(result, Ok(Some(Value::I32(44 as i32)))); + result.map(|_| ()) +} + +// Line 1377 +fn c106_l1377_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c106_l1377_action_invoke"); + let result = instance.call("as-compare-left", &[]); + assert_eq!(result, Ok(Some(Value::I32(43 as i32)))); + result.map(|_| ()) +} + +// Line 1378 +fn c107_l1378_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c107_l1378_action_invoke"); + let result = instance.call("as-compare-right", &[]); + assert_eq!(result, Ok(Some(Value::I32(42 as i32)))); + result.map(|_| ()) +} + +// Line 1380 +fn c108_l1380_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c108_l1380_action_invoke"); + let result = instance.call("as-convert-operand", &[]); + assert_eq!(result, Ok(Some(Value::I32(41 as i32)))); + result.map(|_| ()) +} + +// Line 1382 +fn c109_l1382_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c109_l1382_action_invoke"); + let result = instance.call("as-memory.grow-size", &[]); + assert_eq!(result, Ok(Some(Value::I32(40 as i32)))); + result.map(|_| ()) +} + +// Line 1384 +fn c110_l1384_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c110_l1384_action_invoke"); + let result = instance.call("nested-block-value", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(19 as i32)))); + result.map(|_| ()) +} + +// Line 1385 +fn c111_l1385_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c111_l1385_action_invoke"); + let result = instance.call("nested-block-value", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(17 as i32)))); + result.map(|_| ()) +} + +// Line 1386 +fn c112_l1386_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c112_l1386_action_invoke"); + let result = instance.call("nested-block-value", &[Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(16 as i32)))); + result.map(|_| ()) +} + +// Line 1387 +fn c113_l1387_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c113_l1387_action_invoke"); + let result = instance.call("nested-block-value", &[Value::I32(10 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(16 as i32)))); + result.map(|_| ()) +} + +// Line 1388 +fn c114_l1388_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c114_l1388_action_invoke"); + let result = instance.call("nested-block-value", &[Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(16 as i32)))); + result.map(|_| ()) +} + +// Line 1389 +fn c115_l1389_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c115_l1389_action_invoke"); + let result = instance.call("nested-block-value", &[Value::I32(100000 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(16 as i32)))); + result.map(|_| ()) +} + +// Line 1391 +fn c116_l1391_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c116_l1391_action_invoke"); + let result = instance.call("nested-br-value", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(8 as i32)))); + result.map(|_| ()) +} + +// Line 1392 +fn c117_l1392_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c117_l1392_action_invoke"); + let result = instance.call("nested-br-value", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 1393 +fn c118_l1393_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c118_l1393_action_invoke"); + let result = instance.call("nested-br-value", &[Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(17 as i32)))); + result.map(|_| ()) +} + +// Line 1394 +fn c119_l1394_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c119_l1394_action_invoke"); + let result = instance.call("nested-br-value", &[Value::I32(11 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(17 as i32)))); + result.map(|_| ()) +} + +// Line 1395 +fn c120_l1395_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c120_l1395_action_invoke"); + let result = instance.call("nested-br-value", &[Value::I32(-4 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(17 as i32)))); + result.map(|_| ()) +} + +// Line 1396 +fn c121_l1396_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c121_l1396_action_invoke"); + let result = instance.call("nested-br-value", &[Value::I32(10213210 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(17 as i32)))); + result.map(|_| ()) +} + +// Line 1398 +fn c122_l1398_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c122_l1398_action_invoke"); + let result = instance.call("nested-br_if-value", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(17 as i32)))); + result.map(|_| ()) +} + +// Line 1399 +fn c123_l1399_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c123_l1399_action_invoke"); + let result = instance.call("nested-br_if-value", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 1400 +fn c124_l1400_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c124_l1400_action_invoke"); + let result = instance.call("nested-br_if-value", &[Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(8 as i32)))); + result.map(|_| ()) +} + +// Line 1401 +fn c125_l1401_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c125_l1401_action_invoke"); + let result = instance.call("nested-br_if-value", &[Value::I32(9 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(8 as i32)))); + result.map(|_| ()) +} + +// Line 1402 +fn c126_l1402_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c126_l1402_action_invoke"); + let result = instance.call("nested-br_if-value", &[Value::I32(-9 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(8 as i32)))); + result.map(|_| ()) +} + +// Line 1403 +fn c127_l1403_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c127_l1403_action_invoke"); + let result = instance.call("nested-br_if-value", &[Value::I32(999999 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(8 as i32)))); + result.map(|_| ()) +} + +// Line 1405 +fn c128_l1405_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c128_l1405_action_invoke"); + let result = instance.call("nested-br_if-value-cond", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 1406 +fn c129_l1406_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c129_l1406_action_invoke"); + let result = instance.call("nested-br_if-value-cond", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(8 as i32)))); + result.map(|_| ()) +} + +// Line 1407 +fn c130_l1407_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c130_l1407_action_invoke"); + let result = instance.call("nested-br_if-value-cond", &[Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 1408 +fn c131_l1408_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c131_l1408_action_invoke"); + let result = instance.call("nested-br_if-value-cond", &[Value::I32(3 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 1409 +fn c132_l1409_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c132_l1409_action_invoke"); + let result = instance.call("nested-br_if-value-cond", &[Value::I32(-1000000 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 1410 +fn c133_l1410_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c133_l1410_action_invoke"); + let result = instance.call("nested-br_if-value-cond", &[Value::I32(9423975 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 1412 +fn c134_l1412_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c134_l1412_action_invoke"); + let result = instance.call("nested-br_table-value", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(17 as i32)))); + result.map(|_| ()) +} + +// Line 1413 +fn c135_l1413_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c135_l1413_action_invoke"); + let result = instance.call("nested-br_table-value", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 1414 +fn c136_l1414_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c136_l1414_action_invoke"); + let result = instance.call("nested-br_table-value", &[Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(8 as i32)))); + result.map(|_| ()) +} + +// Line 1415 +fn c137_l1415_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c137_l1415_action_invoke"); + let result = instance.call("nested-br_table-value", &[Value::I32(9 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(8 as i32)))); + result.map(|_| ()) +} + +// Line 1416 +fn c138_l1416_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c138_l1416_action_invoke"); + let result = instance.call("nested-br_table-value", &[Value::I32(-9 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(8 as i32)))); + result.map(|_| ()) +} + +// Line 1417 +fn c139_l1417_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c139_l1417_action_invoke"); + let result = instance.call("nested-br_table-value", &[Value::I32(999999 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(8 as i32)))); + result.map(|_| ()) +} + +// Line 1419 +fn c140_l1419_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c140_l1419_action_invoke"); + let result = instance.call("nested-br_table-value-index", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 1420 +fn c141_l1420_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c141_l1420_action_invoke"); + let result = instance.call("nested-br_table-value-index", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(8 as i32)))); + result.map(|_| ()) +} + +// Line 1421 +fn c142_l1421_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c142_l1421_action_invoke"); + let result = instance.call("nested-br_table-value-index", &[Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 1422 +fn c143_l1422_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c143_l1422_action_invoke"); + let result = instance.call("nested-br_table-value-index", &[Value::I32(3 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 1423 +fn c144_l1423_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c144_l1423_action_invoke"); + let result = instance.call("nested-br_table-value-index", &[Value::I32(-1000000 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 1424 +fn c145_l1424_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c145_l1424_action_invoke"); + let result = instance.call("nested-br_table-value-index", &[Value::I32(9423975 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 1426 +fn c146_l1426_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c146_l1426_action_invoke"); + let result = instance.call("nested-br_table-loop-block", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 1429 +#[test] +fn c147_l1429_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 64, 65, 1, 14, 0, 0, 65, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 1436 +#[test] +fn c148_l1436_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 127, 1, 65, 1, 14, 0, 0, 65, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 1442 +#[test] +fn c149_l1442_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 127, 66, 1, 65, 1, 14, 2, 0, 0, 0, 65, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 1450 +#[test] +fn c150_l1450_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 22, 1, 20, 0, 2, 64, 2, 125, 67, 0, 0, 0, 0, 65, 0, 14, 1, 0, 1, 11, 26, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 1462 +#[test] +fn c151_l1462_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 64, 1, 14, 2, 0, 0, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 1468 +#[test] +fn c152_l1468_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 66, 0, 14, 0, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 1474 +#[test] +fn c153_l1474_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 127, 65, 0, 1, 14, 1, 0, 0, 65, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 1480 +#[test] +fn c154_l1480_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 17, 1, 15, 0, 2, 127, 65, 0, 2, 64, 65, 0, 14, 0, 1, 11, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 1486 +#[test] +fn c155_l1486_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 17, 1, 15, 0, 2, 127, 65, 0, 66, 0, 14, 1, 0, 0, 65, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 1495 +#[test] +fn c156_l1495_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 64, 65, 1, 14, 1, 2, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 1501 +#[test] +fn c157_l1501_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 64, 2, 64, 65, 1, 14, 1, 0, 5, 11, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 1507 +#[test] +fn c158_l1507_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 64, 65, 1, 14, 2, 0, 129, 128, 128, 128, 1, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 1514 +#[test] +fn c159_l1514_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 64, 65, 1, 14, 1, 1, 2, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 1520 +#[test] +fn c160_l1520_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 64, 2, 64, 65, 1, 14, 1, 0, 5, 11, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 1526 +#[test] +fn c161_l1526_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 64, 65, 1, 14, 2, 0, 0, 129, 128, 128, 128, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l1247_action_invoke(&mut instance); + c2_l1248_action_invoke(&mut instance); + c3_l1249_action_invoke(&mut instance); + c4_l1250_action_invoke(&mut instance); + c5_l1252_action_invoke(&mut instance); + c6_l1253_action_invoke(&mut instance); + c7_l1254_action_invoke(&mut instance); + c8_l1255_action_invoke(&mut instance); + c9_l1257_action_invoke(&mut instance); + c10_l1258_action_invoke(&mut instance); + c11_l1259_action_invoke(&mut instance); + c12_l1260_action_invoke(&mut instance); + c13_l1261_action_invoke(&mut instance); + c14_l1262_action_invoke(&mut instance); + c15_l1264_action_invoke(&mut instance); + c16_l1265_action_invoke(&mut instance); + c17_l1266_action_invoke(&mut instance); + c18_l1267_action_invoke(&mut instance); + c19_l1268_action_invoke(&mut instance); + c20_l1269_action_invoke(&mut instance); + c21_l1271_action_invoke(&mut instance); + c22_l1272_action_invoke(&mut instance); + c23_l1273_action_invoke(&mut instance); + c24_l1274_action_invoke(&mut instance); + c25_l1275_action_invoke(&mut instance); + c26_l1276_action_invoke(&mut instance); + c27_l1278_action_invoke(&mut instance); + c28_l1279_action_invoke(&mut instance); + c29_l1280_action_invoke(&mut instance); + c30_l1281_action_invoke(&mut instance); + c31_l1282_action_invoke(&mut instance); + c32_l1283_action_invoke(&mut instance); + c33_l1285_action_invoke(&mut instance); + c34_l1286_action_invoke(&mut instance); + c35_l1287_action_invoke(&mut instance); + c36_l1288_action_invoke(&mut instance); + c37_l1289_action_invoke(&mut instance); + c38_l1290_action_invoke(&mut instance); + c39_l1291_action_invoke(&mut instance); + c40_l1292_action_invoke(&mut instance); + c41_l1293_action_invoke(&mut instance); + c42_l1294_action_invoke(&mut instance); + c43_l1296_action_invoke(&mut instance); + c44_l1297_action_invoke(&mut instance); + c45_l1298_action_invoke(&mut instance); + c46_l1299_action_invoke(&mut instance); + c47_l1300_action_invoke(&mut instance); + c48_l1301_action_invoke(&mut instance); + c49_l1302_action_invoke(&mut instance); + c50_l1303_action_invoke(&mut instance); + c51_l1304_action_invoke(&mut instance); + c52_l1305_action_invoke(&mut instance); + c53_l1307_action_invoke(&mut instance); + c54_l1308_action_invoke(&mut instance); + c55_l1309_action_invoke(&mut instance); + c56_l1310_action_invoke(&mut instance); + c57_l1311_action_invoke(&mut instance); + c58_l1312_action_invoke(&mut instance); + c59_l1313_action_invoke(&mut instance); + c60_l1314_action_invoke(&mut instance); + c61_l1316_action_invoke(&mut instance); + c62_l1317_action_invoke(&mut instance); + c63_l1318_action_invoke(&mut instance); + c64_l1319_action_invoke(&mut instance); + c65_l1321_action_invoke(&mut instance); + c66_l1322_action_invoke(&mut instance); + c67_l1323_action_invoke(&mut instance); + c68_l1325_action_invoke(&mut instance); + c69_l1327_action_invoke(&mut instance); + c70_l1328_action_invoke(&mut instance); + c71_l1329_action_invoke(&mut instance); + c72_l1331_action_invoke(&mut instance); + c73_l1332_action_invoke(&mut instance); + c74_l1333_action_invoke(&mut instance); + c75_l1335_action_invoke(&mut instance); + c76_l1337_action_invoke(&mut instance); + c77_l1338_action_invoke(&mut instance); + c78_l1339_action_invoke(&mut instance); + c79_l1340_action_invoke(&mut instance); + c80_l1341_action_invoke(&mut instance); + c81_l1343_action_invoke(&mut instance); + c82_l1344_action_invoke(&mut instance); + c83_l1345_action_invoke(&mut instance); + c84_l1346_action_invoke(&mut instance); + c85_l1347_action_invoke(&mut instance); + c86_l1349_action_invoke(&mut instance); + c87_l1350_action_invoke(&mut instance); + c88_l1351_action_invoke(&mut instance); + c89_l1353_action_invoke(&mut instance); + c90_l1354_action_invoke(&mut instance); + c91_l1355_action_invoke(&mut instance); + c92_l1356_action_invoke(&mut instance); + c93_l1358_action_invoke(&mut instance); + c94_l1359_action_invoke(&mut instance); + c95_l1360_action_invoke(&mut instance); + c96_l1362_action_invoke(&mut instance); + c97_l1363_action_invoke(&mut instance); + c98_l1365_action_invoke(&mut instance); + c99_l1366_action_invoke(&mut instance); + c100_l1367_action_invoke(&mut instance); + c101_l1368_action_invoke(&mut instance); + c102_l1370_action_invoke(&mut instance); + c103_l1372_action_invoke(&mut instance); + c104_l1373_action_invoke(&mut instance); + c105_l1375_action_invoke(&mut instance); + c106_l1377_action_invoke(&mut instance); + c107_l1378_action_invoke(&mut instance); + c108_l1380_action_invoke(&mut instance); + c109_l1382_action_invoke(&mut instance); + c110_l1384_action_invoke(&mut instance); + c111_l1385_action_invoke(&mut instance); + c112_l1386_action_invoke(&mut instance); + c113_l1387_action_invoke(&mut instance); + c114_l1388_action_invoke(&mut instance); + c115_l1389_action_invoke(&mut instance); + c116_l1391_action_invoke(&mut instance); + c117_l1392_action_invoke(&mut instance); + c118_l1393_action_invoke(&mut instance); + c119_l1394_action_invoke(&mut instance); + c120_l1395_action_invoke(&mut instance); + c121_l1396_action_invoke(&mut instance); + c122_l1398_action_invoke(&mut instance); + c123_l1399_action_invoke(&mut instance); + c124_l1400_action_invoke(&mut instance); + c125_l1401_action_invoke(&mut instance); + c126_l1402_action_invoke(&mut instance); + c127_l1403_action_invoke(&mut instance); + c128_l1405_action_invoke(&mut instance); + c129_l1406_action_invoke(&mut instance); + c130_l1407_action_invoke(&mut instance); + c131_l1408_action_invoke(&mut instance); + c132_l1409_action_invoke(&mut instance); + c133_l1410_action_invoke(&mut instance); + c134_l1412_action_invoke(&mut instance); + c135_l1413_action_invoke(&mut instance); + c136_l1414_action_invoke(&mut instance); + c137_l1415_action_invoke(&mut instance); + c138_l1416_action_invoke(&mut instance); + c139_l1417_action_invoke(&mut instance); + c140_l1419_action_invoke(&mut instance); + c141_l1420_action_invoke(&mut instance); + c142_l1421_action_invoke(&mut instance); + c143_l1422_action_invoke(&mut instance); + c144_l1423_action_invoke(&mut instance); + c145_l1424_action_invoke(&mut instance); + c146_l1426_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/break_drop.rs b/lib/runtime/tests/spectests/break_drop.rs new file mode 100644 index 000000000..6640739d7 --- /dev/null +++ b/lib/runtime/tests/spectests/break_drop.rs @@ -0,0 +1,85 @@ +// 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/break_drop.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 1 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + block ;; label = @1 + br 0 (;@1;) + end) + (func (;1;) (type 0) + block ;; label = @1 + i32.const 1 + br_if 0 (;@1;) + end) + (func (;2;) (type 0) + block ;; label = @1 + i32.const 0 + br_table 0 (;@1;) + end) + (export \"br\" (func 0)) + (export \"br_if\" (func 1)) + (export \"br_table\" (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 7 +fn c1_l7_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l7_action_invoke"); + let result = instance.call("br", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 8 +fn c2_l8_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l8_action_invoke"); + let result = instance.call("br_if", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 9 +fn c3_l9_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l9_action_invoke"); + let result = instance.call("br_table", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l7_action_invoke(&mut instance); + c2_l8_action_invoke(&mut instance); + c3_l9_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/call.rs b/lib/runtime/tests/spectests/call.rs new file mode 100644 index 000000000..2a09ebffc --- /dev/null +++ b/lib/runtime/tests/spectests/call.rs @@ -0,0 +1,931 @@ +// 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/call.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 3 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func (param i32 i32) (result i32))) + (type (;1;) (func (result i32))) + (type (;2;) (func (result i64))) + (type (;3;) (func (result f32))) + (type (;4;) (func (result f64))) + (type (;5;) (func (param i32) (result i32))) + (type (;6;) (func (param i64) (result i64))) + (type (;7;) (func (param f32) (result f32))) + (type (;8;) (func (param f64) (result f64))) + (type (;9;) (func (param f32 i32) (result i32))) + (type (;10;) (func (param i32 i64) (result i64))) + (type (;11;) (func (param f64 f32) (result f32))) + (type (;12;) (func (param i64 f64) (result f64))) + (type (;13;) (func (param i64 i64) (result i64))) + (type (;14;) (func (param i64) (result i32))) + (type (;15;) (func)) + (func (;0;) (type 1) (result i32) + i32.const 306) + (func (;1;) (type 2) (result i64) + i64.const 356) + (func (;2;) (type 3) (result f32) + f32.const 0x1.e64p+11 (;=3890;)) + (func (;3;) (type 4) (result f64) + f64.const 0x1.ec8p+11 (;=3940;)) + (func (;4;) (type 5) (param i32) (result i32) + get_local 0) + (func (;5;) (type 6) (param i64) (result i64) + get_local 0) + (func (;6;) (type 7) (param f32) (result f32) + get_local 0) + (func (;7;) (type 8) (param f64) (result f64) + get_local 0) + (func (;8;) (type 9) (param f32 i32) (result i32) + get_local 1) + (func (;9;) (type 10) (param i32 i64) (result i64) + get_local 1) + (func (;10;) (type 11) (param f64 f32) (result f32) + get_local 1) + (func (;11;) (type 12) (param i64 f64) (result f64) + get_local 1) + (func (;12;) (type 1) (result i32) + call 0) + (func (;13;) (type 2) (result i64) + call 1) + (func (;14;) (type 3) (result f32) + call 2) + (func (;15;) (type 4) (result f64) + call 3) + (func (;16;) (type 1) (result i32) + i32.const 32 + call 4) + (func (;17;) (type 2) (result i64) + i64.const 64 + call 5) + (func (;18;) (type 3) (result f32) + f32.const 0x1.51eb86p+0 (;=1.32;) + call 6) + (func (;19;) (type 4) (result f64) + f64.const 0x1.a3d70a3d70a3dp+0 (;=1.64;) + call 7) + (func (;20;) (type 1) (result i32) + f32.const 0x1.00ccccp+5 (;=32.1;) + i32.const 32 + call 8) + (func (;21;) (type 2) (result i64) + i32.const 32 + i64.const 64 + call 9) + (func (;22;) (type 3) (result f32) + f64.const 0x1p+6 (;=64;) + f32.const 0x1p+5 (;=32;) + call 10) + (func (;23;) (type 4) (result f64) + i64.const 64 + f64.const 0x1.0066666666666p+6 (;=64.1;) + call 11) + (func (;24;) (type 6) (param i64) (result i64) + get_local 0 + i64.eqz + if (result i64) ;; label = @1 + i64.const 1 + else + get_local 0 + get_local 0 + i64.const 1 + i64.sub + call 24 + i64.mul + end) + (func (;25;) (type 13) (param i64 i64) (result i64) + get_local 0 + i64.eqz + if (result i64) ;; label = @1 + get_local 1 + else + get_local 0 + i64.const 1 + i64.sub + get_local 0 + get_local 1 + i64.mul + call 25 + end) + (func (;26;) (type 6) (param i64) (result i64) + get_local 0 + i64.const 1 + i64.le_u + if (result i64) ;; label = @1 + i64.const 1 + else + get_local 0 + i64.const 2 + i64.sub + call 26 + get_local 0 + i64.const 1 + i64.sub + call 26 + i64.add + end) + (func (;27;) (type 14) (param i64) (result i32) + get_local 0 + i64.eqz + if (result i32) ;; label = @1 + i32.const 44 + else + get_local 0 + i64.const 1 + i64.sub + call 28 + end) + (func (;28;) (type 14) (param i64) (result i32) + get_local 0 + i64.eqz + if (result i32) ;; label = @1 + i32.const 99 + else + get_local 0 + i64.const 1 + i64.sub + call 27 + end) + (func (;29;) (type 15) + call 29) + (func (;30;) (type 15) + call 31) + (func (;31;) (type 15) + call 30) + (func (;32;) (type 1) (result i32) + call 0 + i32.const 2 + i32.const 3 + select) + (func (;33;) (type 1) (result i32) + i32.const 2 + call 0 + i32.const 3 + select) + (func (;34;) (type 1) (result i32) + i32.const 2 + i32.const 3 + call 0 + select) + (func (;35;) (type 1) (result i32) + call 0 + if (result i32) ;; label = @1 + i32.const 1 + else + i32.const 2 + end) + (func (;36;) (type 1) (result i32) + block (result i32) ;; label = @1 + call 0 + i32.const 2 + br_if 0 (;@1;) + end) + (func (;37;) (type 1) (result i32) + block (result i32) ;; label = @1 + i32.const 2 + call 0 + br_if 0 (;@1;) + end) + (func (;38;) (type 1) (result i32) + block (result i32) ;; label = @1 + call 0 + i32.const 2 + br_table 0 (;@1;) 0 (;@1;) + end) + (func (;39;) (type 1) (result i32) + block (result i32) ;; label = @1 + i32.const 2 + call 0 + br_table 0 (;@1;) 0 (;@1;) + end) + (func (;40;) (type 0) (param i32 i32) (result i32) + get_local 0) + (func (;41;) (type 1) (result i32) + block (result i32) ;; label = @1 + call 0 + i32.const 2 + i32.const 0 + call_indirect (type 0) + end) + (func (;42;) (type 1) (result i32) + block (result i32) ;; label = @1 + i32.const 2 + call 0 + i32.const 0 + call_indirect (type 0) + end) + (func (;43;) (type 1) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + i32.const 2 + call 0 + call_indirect (type 0) + end) + (func (;44;) (type 15) + call 0 + i32.const 1 + i32.store) + (func (;45;) (type 15) + i32.const 10 + call 0 + i32.store) + (func (;46;) (type 1) (result i32) + call 0 + memory.grow) + (func (;47;) (type 1) (result i32) + call 0 + return) + (func (;48;) (type 15) + call 0 + drop) + (func (;49;) (type 1) (result i32) + block (result i32) ;; label = @1 + call 0 + br 0 (;@1;) + end) + (func (;50;) (type 1) (result i32) + (local i32) + call 0 + set_local 0 + get_local 0) + (func (;51;) (type 1) (result i32) + (local i32) + call 0 + tee_local 0) + (func (;52;) (type 1) (result i32) + call 0 + set_global 0 + get_global 0) + (func (;53;) (type 1) (result i32) + call 0 + i32.load) + (table (;0;) 1 1 anyfunc) + (memory (;0;) 1) + (global (;0;) (mut i32) (i32.const 10)) + (export \"type-i32\" (func 12)) + (export \"type-i64\" (func 13)) + (export \"type-f32\" (func 14)) + (export \"type-f64\" (func 15)) + (export \"type-first-i32\" (func 16)) + (export \"type-first-i64\" (func 17)) + (export \"type-first-f32\" (func 18)) + (export \"type-first-f64\" (func 19)) + (export \"type-second-i32\" (func 20)) + (export \"type-second-i64\" (func 21)) + (export \"type-second-f32\" (func 22)) + (export \"type-second-f64\" (func 23)) + (export \"fac\" (func 24)) + (export \"fac-acc\" (func 25)) + (export \"fib\" (func 26)) + (export \"even\" (func 27)) + (export \"odd\" (func 28)) + (export \"runaway\" (func 29)) + (export \"mutual-runaway\" (func 30)) + (export \"as-select-first\" (func 32)) + (export \"as-select-mid\" (func 33)) + (export \"as-select-last\" (func 34)) + (export \"as-if-condition\" (func 35)) + (export \"as-br_if-first\" (func 36)) + (export \"as-br_if-last\" (func 37)) + (export \"as-br_table-first\" (func 38)) + (export \"as-br_table-last\" (func 39)) + (export \"as-call_indirect-first\" (func 41)) + (export \"as-call_indirect-mid\" (func 42)) + (export \"as-call_indirect-last\" (func 43)) + (export \"as-store-first\" (func 44)) + (export \"as-store-last\" (func 45)) + (export \"as-memory.grow-value\" (func 46)) + (export \"as-return-value\" (func 47)) + (export \"as-drop-operand\" (func 48)) + (export \"as-br-value\" (func 49)) + (export \"as-set_local-value\" (func 50)) + (export \"as-tee_local-value\" (func 51)) + (export \"as-set_global-value\" (func 52)) + (export \"as-load-operand\" (func 53)) + (elem (;0;) (i32.const 0) 40)) + "; + 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 202 +fn c1_l202_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l202_action_invoke"); + let result = instance.call("type-i32", &[]); + assert_eq!(result, Ok(Some(Value::I32(306 as i32)))); + result.map(|_| ()) +} + +// Line 203 +fn c2_l203_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l203_action_invoke"); + let result = instance.call("type-i64", &[]); + assert_eq!(result, Ok(Some(Value::I64(356 as i64)))); + result.map(|_| ()) +} + +// Line 204 +fn c3_l204_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l204_action_invoke"); + let result = instance.call("type-f32", &[]); + assert_eq!(result, Ok(Some(Value::F32((3890.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 205 +fn c4_l205_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l205_action_invoke"); + let result = instance.call("type-f64", &[]); + assert_eq!(result, Ok(Some(Value::F64((3940.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 207 +fn c5_l207_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l207_action_invoke"); + let result = instance.call("type-first-i32", &[]); + assert_eq!(result, Ok(Some(Value::I32(32 as i32)))); + result.map(|_| ()) +} + +// Line 208 +fn c6_l208_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l208_action_invoke"); + let result = instance.call("type-first-i64", &[]); + assert_eq!(result, Ok(Some(Value::I64(64 as i64)))); + result.map(|_| ()) +} + +// Line 209 +fn c7_l209_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l209_action_invoke"); + let result = instance.call("type-first-f32", &[]); + assert_eq!(result, Ok(Some(Value::F32((1.32f32).to_bits())))); + result.map(|_| ()) +} + +// Line 210 +fn c8_l210_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l210_action_invoke"); + let result = instance.call("type-first-f64", &[]); + assert_eq!(result, Ok(Some(Value::F64((1.64f64).to_bits())))); + result.map(|_| ()) +} + +// Line 212 +fn c9_l212_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l212_action_invoke"); + let result = instance.call("type-second-i32", &[]); + assert_eq!(result, Ok(Some(Value::I32(32 as i32)))); + result.map(|_| ()) +} + +// Line 213 +fn c10_l213_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c10_l213_action_invoke"); + let result = instance.call("type-second-i64", &[]); + assert_eq!(result, Ok(Some(Value::I64(64 as i64)))); + result.map(|_| ()) +} + +// Line 214 +fn c11_l214_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c11_l214_action_invoke"); + let result = instance.call("type-second-f32", &[]); + assert_eq!(result, Ok(Some(Value::F32((32.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 215 +fn c12_l215_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c12_l215_action_invoke"); + let result = instance.call("type-second-f64", &[]); + assert_eq!(result, Ok(Some(Value::F64((64.1f64).to_bits())))); + result.map(|_| ()) +} + +// Line 217 +fn c13_l217_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c13_l217_action_invoke"); + let result = instance.call("fac", &[Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 218 +fn c14_l218_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c14_l218_action_invoke"); + let result = instance.call("fac", &[Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 219 +fn c15_l219_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c15_l219_action_invoke"); + let result = instance.call("fac", &[Value::I64(5 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(120 as i64)))); + result.map(|_| ()) +} + +// Line 220 +fn c16_l220_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c16_l220_action_invoke"); + let result = instance.call("fac", &[Value::I64(25 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(7034535277573963776 as i64)))); + result.map(|_| ()) +} + +// Line 221 +fn c17_l221_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c17_l221_action_invoke"); + let result = instance.call("fac-acc", &[Value::I64(0 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 222 +fn c18_l222_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c18_l222_action_invoke"); + let result = instance.call("fac-acc", &[Value::I64(1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 223 +fn c19_l223_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c19_l223_action_invoke"); + let result = instance.call("fac-acc", &[Value::I64(5 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(120 as i64)))); + result.map(|_| ()) +} + +// Line 225 +fn c20_l225_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c20_l225_action_invoke"); + let result = instance.call("fac-acc", &[Value::I64(25 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(7034535277573963776 as i64)))); + result.map(|_| ()) +} + +// Line 229 +fn c21_l229_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c21_l229_action_invoke"); + let result = instance.call("fib", &[Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 230 +fn c22_l230_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c22_l230_action_invoke"); + let result = instance.call("fib", &[Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 231 +fn c23_l231_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c23_l231_action_invoke"); + let result = instance.call("fib", &[Value::I64(2 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(2 as i64)))); + result.map(|_| ()) +} + +// Line 232 +fn c24_l232_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c24_l232_action_invoke"); + let result = instance.call("fib", &[Value::I64(5 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(8 as i64)))); + result.map(|_| ()) +} + +// Line 233 +fn c25_l233_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c25_l233_action_invoke"); + let result = instance.call("fib", &[Value::I64(20 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(10946 as i64)))); + result.map(|_| ()) +} + +// Line 235 +fn c26_l235_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c26_l235_action_invoke"); + let result = instance.call("even", &[Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(44 as i32)))); + result.map(|_| ()) +} + +// Line 236 +fn c27_l236_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c27_l236_action_invoke"); + let result = instance.call("even", &[Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(99 as i32)))); + result.map(|_| ()) +} + +// Line 237 +fn c28_l237_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c28_l237_action_invoke"); + let result = instance.call("even", &[Value::I64(100 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(44 as i32)))); + result.map(|_| ()) +} + +// Line 238 +fn c29_l238_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c29_l238_action_invoke"); + let result = instance.call("even", &[Value::I64(77 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(99 as i32)))); + result.map(|_| ()) +} + +// Line 239 +fn c30_l239_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c30_l239_action_invoke"); + let result = instance.call("odd", &[Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(99 as i32)))); + result.map(|_| ()) +} + +// Line 240 +fn c31_l240_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c31_l240_action_invoke"); + let result = instance.call("odd", &[Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(44 as i32)))); + result.map(|_| ()) +} + +// Line 241 +fn c32_l241_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c32_l241_action_invoke"); + let result = instance.call("odd", &[Value::I64(200 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(99 as i32)))); + result.map(|_| ()) +} + +// Line 242 +fn c33_l242_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c33_l242_action_invoke"); + let result = instance.call("odd", &[Value::I64(77 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(44 as i32)))); + result.map(|_| ()) +} + +// Line 244 + +// Line 245 + +// Line 247 +fn c36_l247_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c36_l247_action_invoke"); + let result = instance.call("as-select-first", &[]); + assert_eq!(result, Ok(Some(Value::I32(306 as i32)))); + result.map(|_| ()) +} + +// Line 248 +fn c37_l248_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c37_l248_action_invoke"); + let result = instance.call("as-select-mid", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 249 +fn c38_l249_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c38_l249_action_invoke"); + let result = instance.call("as-select-last", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 251 +fn c39_l251_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c39_l251_action_invoke"); + let result = instance.call("as-if-condition", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 253 +fn c40_l253_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c40_l253_action_invoke"); + let result = instance.call("as-br_if-first", &[]); + assert_eq!(result, Ok(Some(Value::I32(306 as i32)))); + result.map(|_| ()) +} + +// Line 254 +fn c41_l254_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c41_l254_action_invoke"); + let result = instance.call("as-br_if-last", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 256 +fn c42_l256_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c42_l256_action_invoke"); + let result = instance.call("as-br_table-first", &[]); + assert_eq!(result, Ok(Some(Value::I32(306 as i32)))); + result.map(|_| ()) +} + +// Line 257 +fn c43_l257_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c43_l257_action_invoke"); + let result = instance.call("as-br_table-last", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 259 +fn c44_l259_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c44_l259_action_invoke"); + let result = instance.call("as-call_indirect-first", &[]); + assert_eq!(result, Ok(Some(Value::I32(306 as i32)))); + result.map(|_| ()) +} + +// Line 260 +fn c45_l260_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c45_l260_action_invoke"); + let result = instance.call("as-call_indirect-mid", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 261 +fn c46_l261_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c46_l261_action_invoke"); + let result = instance.call("as-call_indirect-last", &[]); + + result.map(|_| ()) +} + +#[test] +fn c46_l261_assert_trap() { + let mut instance = create_module_1(); + let result = c46_l261_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 263 +fn c47_l263_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c47_l263_action_invoke"); + let result = instance.call("as-store-first", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 264 +fn c48_l264_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c48_l264_action_invoke"); + let result = instance.call("as-store-last", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 266 +fn c49_l266_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c49_l266_action_invoke"); + let result = instance.call("as-memory.grow-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 267 +fn c50_l267_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c50_l267_action_invoke"); + let result = instance.call("as-return-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(306 as i32)))); + result.map(|_| ()) +} + +// Line 268 +fn c51_l268_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c51_l268_action_invoke"); + let result = instance.call("as-drop-operand", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 269 +fn c52_l269_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c52_l269_action_invoke"); + let result = instance.call("as-br-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(306 as i32)))); + result.map(|_| ()) +} + +// Line 270 +fn c53_l270_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c53_l270_action_invoke"); + let result = instance.call("as-set_local-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(306 as i32)))); + result.map(|_| ()) +} + +// Line 271 +fn c54_l271_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c54_l271_action_invoke"); + let result = instance.call("as-tee_local-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(306 as i32)))); + result.map(|_| ()) +} + +// Line 272 +fn c55_l272_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c55_l272_action_invoke"); + let result = instance.call("as-set_global-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(306 as i32)))); + result.map(|_| ()) +} + +// Line 273 +fn c56_l273_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c56_l273_action_invoke"); + let result = instance.call("as-load-operand", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 278 +#[test] +fn c57_l278_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 3, 2, 0, 0, 10, 10, 2, 5, 0, 16, 1, 69, 11, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 285 +#[test] +fn c58_l285_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 8, 2, 96, 0, 0, 96, 0, 1, 126, 3, 3, 2, 0, 1, 10, 12, 2, 5, 0, 16, 1, 69, 11, 4, 0, 66, 1, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 293 +#[test] +fn c59_l293_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 8, 2, 96, 0, 0, 96, 1, 127, 0, 3, 3, 2, 0, 1, 10, 9, 2, 4, 0, 16, 1, 11, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 300 +#[test] +fn c60_l300_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 0, 0, 96, 2, 124, 127, 0, 3, 3, 2, 0, 1, 10, 9, 2, 4, 0, 16, 1, 11, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 307 +#[test] +fn c61_l307_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 3, 2, 0, 0, 10, 11, 2, 6, 0, 65, 1, 16, 1, 11, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 314 +#[test] +fn c62_l314_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 3, 2, 0, 0, 10, 20, 2, 15, 0, 68, 0, 0, 0, 0, 0, 0, 0, 64, 65, 1, 16, 1, 11, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 322 +#[test] +fn c63_l322_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 0, 0, 96, 2, 127, 127, 0, 3, 3, 2, 0, 1, 10, 12, 2, 7, 0, 1, 65, 1, 16, 1, 11, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 329 +#[test] +fn c64_l329_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 0, 0, 96, 2, 127, 127, 0, 3, 3, 2, 0, 1, 10, 12, 2, 7, 0, 65, 1, 1, 16, 1, 11, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 336 +#[test] +fn c65_l336_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 0, 0, 96, 2, 127, 124, 0, 3, 3, 2, 0, 1, 10, 20, 2, 15, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 65, 1, 16, 1, 11, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 343 +#[test] +fn c66_l343_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 0, 0, 96, 2, 124, 127, 0, 3, 3, 2, 0, 1, 10, 20, 2, 15, 0, 65, 1, 68, 0, 0, 0, 0, 0, 0, 240, 63, 16, 1, 11, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 354 +#[test] +fn c67_l354_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 6, 1, 4, 0, 16, 1, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 358 +#[test] +fn c68_l358_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 10, 1, 8, 0, 16, 148, 152, 219, 226, 3, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l202_action_invoke(&mut instance); + c2_l203_action_invoke(&mut instance); + c3_l204_action_invoke(&mut instance); + c4_l205_action_invoke(&mut instance); + c5_l207_action_invoke(&mut instance); + c6_l208_action_invoke(&mut instance); + c7_l209_action_invoke(&mut instance); + c8_l210_action_invoke(&mut instance); + c9_l212_action_invoke(&mut instance); + c10_l213_action_invoke(&mut instance); + c11_l214_action_invoke(&mut instance); + c12_l215_action_invoke(&mut instance); + c13_l217_action_invoke(&mut instance); + c14_l218_action_invoke(&mut instance); + c15_l219_action_invoke(&mut instance); + c16_l220_action_invoke(&mut instance); + c17_l221_action_invoke(&mut instance); + c18_l222_action_invoke(&mut instance); + c19_l223_action_invoke(&mut instance); + c20_l225_action_invoke(&mut instance); + c21_l229_action_invoke(&mut instance); + c22_l230_action_invoke(&mut instance); + c23_l231_action_invoke(&mut instance); + c24_l232_action_invoke(&mut instance); + c25_l233_action_invoke(&mut instance); + c26_l235_action_invoke(&mut instance); + c27_l236_action_invoke(&mut instance); + c28_l237_action_invoke(&mut instance); + c29_l238_action_invoke(&mut instance); + c30_l239_action_invoke(&mut instance); + c31_l240_action_invoke(&mut instance); + c32_l241_action_invoke(&mut instance); + c33_l242_action_invoke(&mut instance); + c36_l247_action_invoke(&mut instance); + c37_l248_action_invoke(&mut instance); + c38_l249_action_invoke(&mut instance); + c39_l251_action_invoke(&mut instance); + c40_l253_action_invoke(&mut instance); + c41_l254_action_invoke(&mut instance); + c42_l256_action_invoke(&mut instance); + c43_l257_action_invoke(&mut instance); + c44_l259_action_invoke(&mut instance); + c45_l260_action_invoke(&mut instance); + c47_l263_action_invoke(&mut instance); + c48_l264_action_invoke(&mut instance); + c49_l266_action_invoke(&mut instance); + c50_l267_action_invoke(&mut instance); + c51_l268_action_invoke(&mut instance); + c52_l269_action_invoke(&mut instance); + c53_l270_action_invoke(&mut instance); + c54_l271_action_invoke(&mut instance); + c55_l272_action_invoke(&mut instance); + c56_l273_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/call_indirect.rs b/lib/runtime/tests/spectests/call_indirect.rs new file mode 100644 index 000000000..f7829e0a4 --- /dev/null +++ b/lib/runtime/tests/spectests/call_indirect.rs @@ -0,0 +1,1619 @@ +// 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/call_indirect.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 3 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func)) + (type (;1;) (func (result i32))) + (type (;2;) (func (result i64))) + (type (;3;) (func (result f32))) + (type (;4;) (func (result f64))) + (type (;5;) (func (param i32) (result i32))) + (type (;6;) (func (param i64) (result i64))) + (type (;7;) (func (param f32) (result f32))) + (type (;8;) (func (param f64) (result f64))) + (type (;9;) (func (param f32 i32) (result i32))) + (type (;10;) (func (param i32 i64) (result i64))) + (type (;11;) (func (param f64 f32) (result f32))) + (type (;12;) (func (param i64 f64) (result f64))) + (type (;13;) (func (param i32) (result i32))) + (type (;14;) (func (param i64) (result i64))) + (type (;15;) (func (param f32) (result f32))) + (type (;16;) (func (param f64) (result f64))) + (type (;17;) (func (param i64))) + (type (;18;) (func (param i64 f64 i32 i64))) + (type (;19;) (func (param i64) (result i32))) + (type (;20;) (func (param i64 f64 i32 i64) (result i32))) + (type (;21;) (func (param i32) (result i64))) + (type (;22;) (func (param i32) (result f32))) + (type (;23;) (func (param i32) (result f64))) + (func (;0;) (type 1) (result i32) + i32.const 306) + (func (;1;) (type 2) (result i64) + i64.const 356) + (func (;2;) (type 3) (result f32) + f32.const 0x1.e64p+11 (;=3890;)) + (func (;3;) (type 4) (result f64) + f64.const 0x1.ec8p+11 (;=3940;)) + (func (;4;) (type 5) (param i32) (result i32) + get_local 0) + (func (;5;) (type 6) (param i64) (result i64) + get_local 0) + (func (;6;) (type 7) (param f32) (result f32) + get_local 0) + (func (;7;) (type 8) (param f64) (result f64) + get_local 0) + (func (;8;) (type 10) (param i32 i64) (result i64) + get_local 1) + (func (;9;) (type 12) (param i64 f64) (result f64) + get_local 1) + (func (;10;) (type 9) (param f32 i32) (result i32) + get_local 1) + (func (;11;) (type 11) (param f64 f32) (result f32) + get_local 1) + (func (;12;) (type 13) (param i32) (result i32) + get_local 0) + (func (;13;) (type 14) (param i64) (result i64) + get_local 0) + (func (;14;) (type 15) (param f32) (result f32) + get_local 0) + (func (;15;) (type 16) (param f64) (result f64) + get_local 0) + (func (;16;) (type 0) + i32.const 0 + call_indirect (type 0) + i64.const 0 + i32.const 0 + call_indirect (type 17) + i64.const 0 + f64.const 0x0p+0 (;=0;) + i32.const 0 + i64.const 0 + i32.const 0 + call_indirect (type 18) + i32.const 0 + call_indirect (type 0) + i32.const 0 + call_indirect (type 1) + i32.eqz + drop + i32.const 0 + call_indirect (type 1) + i32.eqz + drop + i64.const 0 + i32.const 0 + call_indirect (type 19) + i32.eqz + drop + i64.const 0 + f64.const 0x0p+0 (;=0;) + i32.const 0 + i64.const 0 + i32.const 0 + call_indirect (type 20) + i32.eqz + drop + i64.const 0 + i32.const 0 + call_indirect (type 6) + i64.eqz + drop) + (func (;17;) (type 1) (result i32) + i32.const 0 + call_indirect (type 1)) + (func (;18;) (type 2) (result i64) + i32.const 1 + call_indirect (type 2)) + (func (;19;) (type 3) (result f32) + i32.const 2 + call_indirect (type 3)) + (func (;20;) (type 4) (result f64) + i32.const 3 + call_indirect (type 4)) + (func (;21;) (type 2) (result i64) + i64.const 100 + i32.const 5 + call_indirect (type 6)) + (func (;22;) (type 1) (result i32) + i32.const 32 + i32.const 4 + call_indirect (type 5)) + (func (;23;) (type 2) (result i64) + i64.const 64 + i32.const 5 + call_indirect (type 6)) + (func (;24;) (type 3) (result f32) + f32.const 0x1.51eb86p+0 (;=1.32;) + i32.const 6 + call_indirect (type 7)) + (func (;25;) (type 4) (result f64) + f64.const 0x1.a3d70a3d70a3dp+0 (;=1.64;) + i32.const 7 + call_indirect (type 8)) + (func (;26;) (type 1) (result i32) + f32.const 0x1.00ccccp+5 (;=32.1;) + i32.const 32 + i32.const 8 + call_indirect (type 9)) + (func (;27;) (type 2) (result i64) + i32.const 32 + i64.const 64 + i32.const 9 + call_indirect (type 10)) + (func (;28;) (type 3) (result f32) + f64.const 0x1p+6 (;=64;) + f32.const 0x1p+5 (;=32;) + i32.const 10 + call_indirect (type 11)) + (func (;29;) (type 4) (result f64) + i64.const 64 + f64.const 0x1.0066666666666p+6 (;=64.1;) + i32.const 11 + call_indirect (type 12)) + (func (;30;) (type 10) (param i32 i64) (result i64) + get_local 1 + get_local 0 + call_indirect (type 6)) + (func (;31;) (type 21) (param i32) (result i64) + i64.const 9 + get_local 0 + call_indirect (type 14)) + (func (;32;) (type 5) (param i32) (result i32) + i32.const 9 + get_local 0 + call_indirect (type 13)) + (func (;33;) (type 22) (param i32) (result f32) + f32.const 0x1.2p+3 (;=9;) + get_local 0 + call_indirect (type 15)) + (func (;34;) (type 23) (param i32) (result f64) + f64.const 0x1.2p+3 (;=9;) + get_local 0 + call_indirect (type 16)) + (func (;35;) (type 6) (param i64) (result i64) + get_local 0 + i64.eqz + if (result i64) ;; label = @1 + i64.const 1 + else + get_local 0 + get_local 0 + i64.const 1 + i64.sub + i32.const 12 + call_indirect (type 6) + i64.mul + end) + (func (;36;) (type 6) (param i64) (result i64) + get_local 0 + i64.const 1 + i64.le_u + if (result i64) ;; label = @1 + i64.const 1 + else + get_local 0 + i64.const 2 + i64.sub + i32.const 13 + call_indirect (type 6) + get_local 0 + i64.const 1 + i64.sub + i32.const 13 + call_indirect (type 6) + i64.add + end) + (func (;37;) (type 5) (param i32) (result i32) + get_local 0 + i32.eqz + if (result i32) ;; label = @1 + i32.const 1 + else + get_local 0 + get_local 0 + i32.const 1 + i32.sub + i32.const 23 + call_indirect (type 5) + i32.mul + end) + (func (;38;) (type 7) (param f32) (result f32) + get_local 0 + f32.const 0x0p+0 (;=0;) + f32.eq + if (result f32) ;; label = @1 + f32.const 0x1p+0 (;=1;) + else + get_local 0 + get_local 0 + f32.const 0x1p+0 (;=1;) + f32.sub + i32.const 24 + call_indirect (type 7) + f32.mul + end) + (func (;39;) (type 8) (param f64) (result f64) + get_local 0 + f64.const 0x0p+0 (;=0;) + f64.eq + if (result f64) ;; label = @1 + f64.const 0x1p+0 (;=1;) + else + get_local 0 + get_local 0 + f64.const 0x1p+0 (;=1;) + f64.sub + i32.const 25 + call_indirect (type 8) + f64.mul + end) + (func (;40;) (type 5) (param i32) (result i32) + get_local 0 + i32.const 1 + i32.le_u + if (result i32) ;; label = @1 + i32.const 1 + else + get_local 0 + i32.const 2 + i32.sub + i32.const 26 + call_indirect (type 5) + get_local 0 + i32.const 1 + i32.sub + i32.const 26 + call_indirect (type 5) + i32.add + end) + (func (;41;) (type 7) (param f32) (result f32) + get_local 0 + f32.const 0x1p+0 (;=1;) + f32.le + if (result f32) ;; label = @1 + f32.const 0x1p+0 (;=1;) + else + get_local 0 + f32.const 0x1p+1 (;=2;) + f32.sub + i32.const 27 + call_indirect (type 7) + get_local 0 + f32.const 0x1p+0 (;=1;) + f32.sub + i32.const 27 + call_indirect (type 7) + f32.add + end) + (func (;42;) (type 8) (param f64) (result f64) + get_local 0 + f64.const 0x1p+0 (;=1;) + f64.le + if (result f64) ;; label = @1 + f64.const 0x1p+0 (;=1;) + else + get_local 0 + f64.const 0x1p+1 (;=2;) + f64.sub + i32.const 28 + call_indirect (type 8) + get_local 0 + f64.const 0x1p+0 (;=1;) + f64.sub + i32.const 28 + call_indirect (type 8) + f64.add + end) + (func (;43;) (type 5) (param i32) (result i32) + get_local 0 + i32.eqz + if (result i32) ;; label = @1 + i32.const 44 + else + get_local 0 + i32.const 1 + i32.sub + i32.const 15 + call_indirect (type 5) + end) + (func (;44;) (type 5) (param i32) (result i32) + get_local 0 + i32.eqz + if (result i32) ;; label = @1 + i32.const 99 + else + get_local 0 + i32.const 1 + i32.sub + i32.const 14 + call_indirect (type 5) + end) + (func (;45;) (type 0) + i32.const 16 + call_indirect (type 0)) + (func (;46;) (type 0) + i32.const 18 + call_indirect (type 0)) + (func (;47;) (type 0) + i32.const 17 + call_indirect (type 0)) + (func (;48;) (type 1) (result i32) + i32.const 0 + call_indirect (type 1) + i32.const 2 + i32.const 3 + select) + (func (;49;) (type 1) (result i32) + i32.const 2 + i32.const 0 + call_indirect (type 1) + i32.const 3 + select) + (func (;50;) (type 1) (result i32) + i32.const 2 + i32.const 3 + i32.const 0 + call_indirect (type 1) + select) + (func (;51;) (type 1) (result i32) + i32.const 0 + call_indirect (type 1) + if (result i32) ;; label = @1 + i32.const 1 + else + i32.const 2 + end) + (func (;52;) (type 2) (result i64) + block (result i64) ;; label = @1 + i32.const 1 + call_indirect (type 2) + i32.const 2 + br_if 0 (;@1;) + end) + (func (;53;) (type 1) (result i32) + block (result i32) ;; label = @1 + i32.const 2 + i32.const 0 + call_indirect (type 1) + br_if 0 (;@1;) + end) + (func (;54;) (type 3) (result f32) + block (result f32) ;; label = @1 + i32.const 2 + call_indirect (type 3) + i32.const 2 + br_table 0 (;@1;) 0 (;@1;) + end) + (func (;55;) (type 1) (result i32) + block (result i32) ;; label = @1 + i32.const 2 + i32.const 0 + call_indirect (type 1) + br_table 0 (;@1;) 0 (;@1;) + end) + (func (;56;) (type 0) + i32.const 0 + call_indirect (type 1) + i32.const 1 + i32.store) + (func (;57;) (type 0) + i32.const 10 + i32.const 3 + call_indirect (type 4) + f64.store) + (func (;58;) (type 1) (result i32) + i32.const 0 + call_indirect (type 1) + memory.grow) + (func (;59;) (type 1) (result i32) + i32.const 1 + i32.const 4 + call_indirect (type 5) + return) + (func (;60;) (type 0) + i64.const 1 + i32.const 5 + call_indirect (type 6) + drop) + (func (;61;) (type 3) (result f32) + block (result f32) ;; label = @1 + f32.const 0x1p+0 (;=1;) + i32.const 6 + call_indirect (type 7) + br 0 (;@1;) + end) + (func (;62;) (type 4) (result f64) + (local f64) + f64.const 0x1p+0 (;=1;) + i32.const 7 + call_indirect (type 8) + set_local 0 + get_local 0) + (func (;63;) (type 4) (result f64) + (local f64) + f64.const 0x1p+0 (;=1;) + i32.const 7 + call_indirect (type 8) + tee_local 0) + (func (;64;) (type 4) (result f64) + f64.const 0x1p+0 (;=1;) + i32.const 7 + call_indirect (type 8) + set_global 0 + get_global 0) + (func (;65;) (type 1) (result i32) + i32.const 0 + call_indirect (type 1) + i32.load) + (table (;0;) 29 29 anyfunc) + (memory (;0;) 1) + (global (;0;) (mut f64) (f64.const 0x1.4p+3 (;=10;))) + (export \"type-i32\" (func 17)) + (export \"type-i64\" (func 18)) + (export \"type-f32\" (func 19)) + (export \"type-f64\" (func 20)) + (export \"type-index\" (func 21)) + (export \"type-first-i32\" (func 22)) + (export \"type-first-i64\" (func 23)) + (export \"type-first-f32\" (func 24)) + (export \"type-first-f64\" (func 25)) + (export \"type-second-i32\" (func 26)) + (export \"type-second-i64\" (func 27)) + (export \"type-second-f32\" (func 28)) + (export \"type-second-f64\" (func 29)) + (export \"dispatch\" (func 30)) + (export \"dispatch-structural-i64\" (func 31)) + (export \"dispatch-structural-i32\" (func 32)) + (export \"dispatch-structural-f32\" (func 33)) + (export \"dispatch-structural-f64\" (func 34)) + (export \"fac-i64\" (func 35)) + (export \"fib-i64\" (func 36)) + (export \"fac-i32\" (func 37)) + (export \"fac-f32\" (func 38)) + (export \"fac-f64\" (func 39)) + (export \"fib-i32\" (func 40)) + (export \"fib-f32\" (func 41)) + (export \"fib-f64\" (func 42)) + (export \"even\" (func 43)) + (export \"odd\" (func 44)) + (export \"runaway\" (func 45)) + (export \"mutual-runaway\" (func 46)) + (export \"as-select-first\" (func 48)) + (export \"as-select-mid\" (func 49)) + (export \"as-select-last\" (func 50)) + (export \"as-if-condition\" (func 51)) + (export \"as-br_if-first\" (func 52)) + (export \"as-br_if-last\" (func 53)) + (export \"as-br_table-first\" (func 54)) + (export \"as-br_table-last\" (func 55)) + (export \"as-store-first\" (func 56)) + (export \"as-store-last\" (func 57)) + (export \"as-memory.grow-value\" (func 58)) + (export \"as-return-value\" (func 59)) + (export \"as-drop-operand\" (func 60)) + (export \"as-br-value\" (func 61)) + (export \"as-set_local-value\" (func 62)) + (export \"as-tee_local-value\" (func 63)) + (export \"as-set_global-value\" (func 64)) + (export \"as-load-operand\" (func 65)) + (elem (;0;) (i32.const 0) 0 1 2 3 4 5 6 7 10 8 11 9 35 36 43 44 45 46 47 12 13 14 15 37 38 39 40 41 42)) + "; + 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 388 +fn c1_l388_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l388_action_invoke"); + let result = instance.call("type-i32", &[]); + assert_eq!(result, Ok(Some(Value::I32(306 as i32)))); + result.map(|_| ()) +} + +// Line 389 +fn c2_l389_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l389_action_invoke"); + let result = instance.call("type-i64", &[]); + assert_eq!(result, Ok(Some(Value::I64(356 as i64)))); + result.map(|_| ()) +} + +// Line 390 +fn c3_l390_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l390_action_invoke"); + let result = instance.call("type-f32", &[]); + assert_eq!(result, Ok(Some(Value::F32((3890.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 391 +fn c4_l391_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l391_action_invoke"); + let result = instance.call("type-f64", &[]); + assert_eq!(result, Ok(Some(Value::F64((3940.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 393 +fn c5_l393_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l393_action_invoke"); + let result = instance.call("type-index", &[]); + assert_eq!(result, Ok(Some(Value::I64(100 as i64)))); + result.map(|_| ()) +} + +// Line 395 +fn c6_l395_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l395_action_invoke"); + let result = instance.call("type-first-i32", &[]); + assert_eq!(result, Ok(Some(Value::I32(32 as i32)))); + result.map(|_| ()) +} + +// Line 396 +fn c7_l396_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l396_action_invoke"); + let result = instance.call("type-first-i64", &[]); + assert_eq!(result, Ok(Some(Value::I64(64 as i64)))); + result.map(|_| ()) +} + +// Line 397 +fn c8_l397_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l397_action_invoke"); + let result = instance.call("type-first-f32", &[]); + assert_eq!(result, Ok(Some(Value::F32((1.32f32).to_bits())))); + result.map(|_| ()) +} + +// Line 398 +fn c9_l398_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l398_action_invoke"); + let result = instance.call("type-first-f64", &[]); + assert_eq!(result, Ok(Some(Value::F64((1.64f64).to_bits())))); + result.map(|_| ()) +} + +// Line 400 +fn c10_l400_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c10_l400_action_invoke"); + let result = instance.call("type-second-i32", &[]); + assert_eq!(result, Ok(Some(Value::I32(32 as i32)))); + result.map(|_| ()) +} + +// Line 401 +fn c11_l401_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c11_l401_action_invoke"); + let result = instance.call("type-second-i64", &[]); + assert_eq!(result, Ok(Some(Value::I64(64 as i64)))); + result.map(|_| ()) +} + +// Line 402 +fn c12_l402_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c12_l402_action_invoke"); + let result = instance.call("type-second-f32", &[]); + assert_eq!(result, Ok(Some(Value::F32((32.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 403 +fn c13_l403_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c13_l403_action_invoke"); + let result = instance.call("type-second-f64", &[]); + assert_eq!(result, Ok(Some(Value::F64((64.1f64).to_bits())))); + result.map(|_| ()) +} + +// Line 405 +fn c14_l405_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c14_l405_action_invoke"); + let result = instance.call("dispatch", &[Value::I32(5 as i32), Value::I64(2 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(2 as i64)))); + result.map(|_| ()) +} + +// Line 406 +fn c15_l406_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c15_l406_action_invoke"); + let result = instance.call("dispatch", &[Value::I32(5 as i32), Value::I64(5 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(5 as i64)))); + result.map(|_| ()) +} + +// Line 407 +fn c16_l407_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c16_l407_action_invoke"); + let result = instance.call("dispatch", &[Value::I32(12 as i32), Value::I64(5 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(120 as i64)))); + result.map(|_| ()) +} + +// Line 408 +fn c17_l408_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c17_l408_action_invoke"); + let result = instance.call("dispatch", &[Value::I32(13 as i32), Value::I64(5 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(8 as i64)))); + result.map(|_| ()) +} + +// Line 409 +fn c18_l409_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c18_l409_action_invoke"); + let result = instance.call("dispatch", &[Value::I32(20 as i32), Value::I64(2 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(2 as i64)))); + result.map(|_| ()) +} + +// Line 420 +fn c19_l420_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c19_l420_action_invoke"); + let result = instance.call("dispatch-structural-i64", &[Value::I32(5 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(9 as i64)))); + result.map(|_| ()) +} + +// Line 421 +fn c20_l421_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c20_l421_action_invoke"); + let result = instance.call("dispatch-structural-i64", &[Value::I32(12 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(362880 as i64)))); + result.map(|_| ()) +} + +// Line 422 +fn c21_l422_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c21_l422_action_invoke"); + let result = instance.call("dispatch-structural-i64", &[Value::I32(13 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(55 as i64)))); + result.map(|_| ()) +} + +// Line 423 +fn c22_l423_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c22_l423_action_invoke"); + let result = instance.call("dispatch-structural-i64", &[Value::I32(20 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(9 as i64)))); + result.map(|_| ()) +} + +// Line 429 +fn c23_l429_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c23_l429_action_invoke"); + let result = instance.call("dispatch-structural-i32", &[Value::I32(4 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 430 +fn c24_l430_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c24_l430_action_invoke"); + let result = instance.call("dispatch-structural-i32", &[Value::I32(23 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(362880 as i32)))); + result.map(|_| ()) +} + +// Line 431 +fn c25_l431_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c25_l431_action_invoke"); + let result = instance.call("dispatch-structural-i32", &[Value::I32(26 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(55 as i32)))); + result.map(|_| ()) +} + +// Line 432 +fn c26_l432_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c26_l432_action_invoke"); + let result = instance.call("dispatch-structural-i32", &[Value::I32(19 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 438 +fn c27_l438_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c27_l438_action_invoke"); + let result = instance.call("dispatch-structural-f32", &[Value::I32(6 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((9.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 439 +fn c28_l439_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c28_l439_action_invoke"); + let result = instance.call("dispatch-structural-f32", &[Value::I32(24 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((362880.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 440 +fn c29_l440_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c29_l440_action_invoke"); + let result = instance.call("dispatch-structural-f32", &[Value::I32(27 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((55.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 441 +fn c30_l441_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c30_l441_action_invoke"); + let result = instance.call("dispatch-structural-f32", &[Value::I32(21 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((9.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 447 +fn c31_l447_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c31_l447_action_invoke"); + let result = instance.call("dispatch-structural-f64", &[Value::I32(7 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((9.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 448 +fn c32_l448_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c32_l448_action_invoke"); + let result = instance.call("dispatch-structural-f64", &[Value::I32(25 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((362880.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 449 +fn c33_l449_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c33_l449_action_invoke"); + let result = instance.call("dispatch-structural-f64", &[Value::I32(28 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((55.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 450 +fn c34_l450_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c34_l450_action_invoke"); + let result = instance.call("dispatch-structural-f64", &[Value::I32(22 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((9.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 456 +fn c35_l456_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c35_l456_action_invoke"); + let result = instance.call("fac-i64", &[Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 457 +fn c36_l457_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c36_l457_action_invoke"); + let result = instance.call("fac-i64", &[Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 458 +fn c37_l458_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c37_l458_action_invoke"); + let result = instance.call("fac-i64", &[Value::I64(5 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(120 as i64)))); + result.map(|_| ()) +} + +// Line 459 +fn c38_l459_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c38_l459_action_invoke"); + let result = instance.call("fac-i64", &[Value::I64(25 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(7034535277573963776 as i64)))); + result.map(|_| ()) +} + +// Line 461 +fn c39_l461_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c39_l461_action_invoke"); + let result = instance.call("fac-i32", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 462 +fn c40_l462_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c40_l462_action_invoke"); + let result = instance.call("fac-i32", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 463 +fn c41_l463_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c41_l463_action_invoke"); + let result = instance.call("fac-i32", &[Value::I32(5 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(120 as i32)))); + result.map(|_| ()) +} + +// Line 464 +fn c42_l464_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c42_l464_action_invoke"); + let result = instance.call("fac-i32", &[Value::I32(10 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(3628800 as i32)))); + result.map(|_| ()) +} + +// Line 466 +fn c43_l466_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c43_l466_action_invoke"); + let result = instance.call("fac-f32", &[Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 467 +fn c44_l467_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c44_l467_action_invoke"); + let result = instance.call("fac-f32", &[Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 468 +fn c45_l468_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c45_l468_action_invoke"); + let result = instance.call("fac-f32", &[Value::F32((5.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((120.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 469 +fn c46_l469_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c46_l469_action_invoke"); + let result = instance.call("fac-f32", &[Value::F32((10.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((3628800.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 471 +fn c47_l471_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c47_l471_action_invoke"); + let result = instance.call("fac-f64", &[Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 472 +fn c48_l472_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c48_l472_action_invoke"); + let result = instance.call("fac-f64", &[Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 473 +fn c49_l473_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c49_l473_action_invoke"); + let result = instance.call("fac-f64", &[Value::F64((5.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((120.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 474 +fn c50_l474_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c50_l474_action_invoke"); + let result = instance.call("fac-f64", &[Value::F64((10.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((3628800.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 476 +fn c51_l476_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c51_l476_action_invoke"); + let result = instance.call("fib-i64", &[Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 477 +fn c52_l477_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c52_l477_action_invoke"); + let result = instance.call("fib-i64", &[Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 478 +fn c53_l478_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c53_l478_action_invoke"); + let result = instance.call("fib-i64", &[Value::I64(2 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(2 as i64)))); + result.map(|_| ()) +} + +// Line 479 +fn c54_l479_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c54_l479_action_invoke"); + let result = instance.call("fib-i64", &[Value::I64(5 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(8 as i64)))); + result.map(|_| ()) +} + +// Line 480 +fn c55_l480_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c55_l480_action_invoke"); + let result = instance.call("fib-i64", &[Value::I64(20 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(10946 as i64)))); + result.map(|_| ()) +} + +// Line 482 +fn c56_l482_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c56_l482_action_invoke"); + let result = instance.call("fib-i32", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 483 +fn c57_l483_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c57_l483_action_invoke"); + let result = instance.call("fib-i32", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 484 +fn c58_l484_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c58_l484_action_invoke"); + let result = instance.call("fib-i32", &[Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 485 +fn c59_l485_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c59_l485_action_invoke"); + let result = instance.call("fib-i32", &[Value::I32(5 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(8 as i32)))); + result.map(|_| ()) +} + +// Line 486 +fn c60_l486_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c60_l486_action_invoke"); + let result = instance.call("fib-i32", &[Value::I32(20 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(10946 as i32)))); + result.map(|_| ()) +} + +// Line 488 +fn c61_l488_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c61_l488_action_invoke"); + let result = instance.call("fib-f32", &[Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 489 +fn c62_l489_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c62_l489_action_invoke"); + let result = instance.call("fib-f32", &[Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 490 +fn c63_l490_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c63_l490_action_invoke"); + let result = instance.call("fib-f32", &[Value::F32((2.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((2.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 491 +fn c64_l491_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c64_l491_action_invoke"); + let result = instance.call("fib-f32", &[Value::F32((5.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((8.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 492 +fn c65_l492_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c65_l492_action_invoke"); + let result = instance.call("fib-f32", &[Value::F32((20.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((10946.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 494 +fn c66_l494_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c66_l494_action_invoke"); + let result = instance.call("fib-f64", &[Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 495 +fn c67_l495_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c67_l495_action_invoke"); + let result = instance.call("fib-f64", &[Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 496 +fn c68_l496_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c68_l496_action_invoke"); + let result = instance.call("fib-f64", &[Value::F64((2.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((2.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 497 +fn c69_l497_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c69_l497_action_invoke"); + let result = instance.call("fib-f64", &[Value::F64((5.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((8.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 498 +fn c70_l498_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c70_l498_action_invoke"); + let result = instance.call("fib-f64", &[Value::F64((20.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((10946.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 500 +fn c71_l500_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c71_l500_action_invoke"); + let result = instance.call("even", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(44 as i32)))); + result.map(|_| ()) +} + +// Line 501 +fn c72_l501_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c72_l501_action_invoke"); + let result = instance.call("even", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(99 as i32)))); + result.map(|_| ()) +} + +// Line 502 +fn c73_l502_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c73_l502_action_invoke"); + let result = instance.call("even", &[Value::I32(100 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(44 as i32)))); + result.map(|_| ()) +} + +// Line 503 +fn c74_l503_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c74_l503_action_invoke"); + let result = instance.call("even", &[Value::I32(77 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(99 as i32)))); + result.map(|_| ()) +} + +// Line 504 +fn c75_l504_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c75_l504_action_invoke"); + let result = instance.call("odd", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(99 as i32)))); + result.map(|_| ()) +} + +// Line 505 +fn c76_l505_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c76_l505_action_invoke"); + let result = instance.call("odd", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(44 as i32)))); + result.map(|_| ()) +} + +// Line 506 +fn c77_l506_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c77_l506_action_invoke"); + let result = instance.call("odd", &[Value::I32(200 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(99 as i32)))); + result.map(|_| ()) +} + +// Line 507 +fn c78_l507_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c78_l507_action_invoke"); + let result = instance.call("odd", &[Value::I32(77 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(44 as i32)))); + result.map(|_| ()) +} + +// Line 509 + +// Line 510 + +// Line 512 +fn c81_l512_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c81_l512_action_invoke"); + let result = instance.call("as-select-first", &[]); + assert_eq!(result, Ok(Some(Value::I32(306 as i32)))); + result.map(|_| ()) +} + +// Line 513 +fn c82_l513_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c82_l513_action_invoke"); + let result = instance.call("as-select-mid", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 514 +fn c83_l514_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c83_l514_action_invoke"); + let result = instance.call("as-select-last", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 516 +fn c84_l516_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c84_l516_action_invoke"); + let result = instance.call("as-if-condition", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 518 +fn c85_l518_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c85_l518_action_invoke"); + let result = instance.call("as-br_if-first", &[]); + assert_eq!(result, Ok(Some(Value::I64(356 as i64)))); + result.map(|_| ()) +} + +// Line 519 +fn c86_l519_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c86_l519_action_invoke"); + let result = instance.call("as-br_if-last", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 521 +fn c87_l521_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c87_l521_action_invoke"); + let result = instance.call("as-br_table-first", &[]); + assert_eq!(result, Ok(Some(Value::F32((3890.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 522 +fn c88_l522_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c88_l522_action_invoke"); + let result = instance.call("as-br_table-last", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 524 +fn c89_l524_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c89_l524_action_invoke"); + let result = instance.call("as-store-first", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 525 +fn c90_l525_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c90_l525_action_invoke"); + let result = instance.call("as-store-last", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 527 +fn c91_l527_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c91_l527_action_invoke"); + let result = instance.call("as-memory.grow-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 528 +fn c92_l528_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c92_l528_action_invoke"); + let result = instance.call("as-return-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 529 +fn c93_l529_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c93_l529_action_invoke"); + let result = instance.call("as-drop-operand", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 530 +fn c94_l530_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c94_l530_action_invoke"); + let result = instance.call("as-br-value", &[]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 531 +fn c95_l531_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c95_l531_action_invoke"); + let result = instance.call("as-set_local-value", &[]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 532 +fn c96_l532_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c96_l532_action_invoke"); + let result = instance.call("as-tee_local-value", &[]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 533 +fn c97_l533_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c97_l533_action_invoke"); + let result = instance.call("as-set_global-value", &[]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 534 +fn c98_l534_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c98_l534_action_invoke"); + let result = instance.call("as-load-operand", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 539 +#[test] +fn c99_l539_assert_malformed() { + let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 40, 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 32, 32, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 32, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 551 +#[test] +fn c100_l551_assert_malformed() { + let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 40, 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 32, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 32, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 563 +#[test] +fn c101_l563_assert_malformed() { + let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 40, 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 32, 32, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 32, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 575 +#[test] +fn c102_l575_assert_malformed() { + let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 40, 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 32, 32, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 32, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 587 +#[test] +fn c103_l587_assert_malformed() { + let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 40, 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 32, 32, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 32, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 599 +#[test] +fn c104_l599_assert_malformed() { + let wasm_binary = [40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 40, 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 609 +#[test] +fn c105_l609_assert_malformed() { + let wasm_binary = [40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, 102, 117, 110, 99, 32, 40, 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 112, 97, 114, 97, 109, 32, 36, 120, 32, 105, 51, 50, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 616 +#[test] +fn c106_l616_assert_malformed() { + let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 41, 41, 40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 40, 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 626 +#[test] +fn c107_l626_assert_malformed() { + let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 40, 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 636 +#[test] +fn c108_l636_assert_malformed() { + let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, 102, 117, 110, 99, 32, 32, 40, 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 646 +#[test] +fn c109_l646_assert_malformed() { + let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 40, 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 32, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 32, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 661 +#[test] +fn c110_l661_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 0, 17, 0, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 669 +#[test] +fn c111_l669_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 10, 10, 1, 8, 0, 65, 0, 17, 0, 0, 69, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 677 +#[test] +fn c112_l677_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 8, 2, 96, 0, 1, 126, 96, 0, 0, 3, 2, 1, 1, 4, 4, 1, 112, 0, 0, 10, 10, 1, 8, 0, 65, 0, 17, 0, 0, 69, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 686 +#[test] +fn c113_l686_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 8, 2, 96, 1, 127, 0, 96, 0, 0, 3, 2, 1, 1, 4, 4, 1, 112, 0, 0, 10, 9, 1, 7, 0, 65, 0, 17, 0, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 694 +#[test] +fn c114_l694_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 2, 124, 127, 0, 96, 0, 0, 3, 2, 1, 1, 4, 4, 1, 112, 0, 0, 10, 9, 1, 7, 0, 65, 0, 17, 0, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 702 +#[test] +fn c115_l702_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 10, 11, 1, 9, 0, 65, 1, 65, 0, 17, 0, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 710 +#[test] +fn c116_l710_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 10, 20, 1, 18, 0, 68, 0, 0, 0, 0, 0, 0, 0, 64, 65, 1, 65, 0, 17, 0, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 721 +#[test] +fn c117_l721_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 8, 2, 96, 1, 127, 0, 96, 0, 0, 3, 2, 1, 1, 4, 4, 1, 112, 0, 0, 10, 10, 1, 8, 0, 65, 1, 1, 17, 0, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 729 +#[test] +fn c118_l729_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 8, 2, 96, 1, 127, 0, 96, 0, 0, 3, 2, 1, 1, 4, 4, 1, 112, 0, 0, 10, 11, 1, 9, 0, 65, 0, 66, 1, 17, 0, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 738 +#[test] +fn c119_l738_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 2, 127, 127, 0, 96, 0, 0, 3, 2, 1, 1, 4, 4, 1, 112, 0, 0, 10, 12, 1, 10, 0, 1, 65, 1, 65, 0, 17, 0, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 748 +#[test] +fn c120_l748_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 2, 127, 127, 0, 96, 0, 0, 3, 2, 1, 1, 4, 4, 1, 112, 0, 0, 10, 12, 1, 10, 0, 65, 1, 1, 65, 0, 17, 0, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 758 +#[test] +fn c121_l758_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 2, 127, 124, 0, 96, 0, 0, 3, 2, 1, 1, 4, 4, 1, 112, 0, 0, 10, 20, 1, 18, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 65, 1, 65, 0, 17, 0, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 768 +#[test] +fn c122_l768_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 2, 124, 127, 0, 96, 0, 0, 3, 2, 1, 1, 4, 4, 1, 112, 0, 0, 10, 20, 1, 18, 0, 65, 1, 68, 0, 0, 0, 0, 0, 0, 240, 63, 65, 0, 17, 0, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 782 +#[test] +fn c123_l782_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 10, 9, 1, 7, 0, 65, 0, 17, 1, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 789 +#[test] +fn c124_l789_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 10, 13, 1, 11, 0, 65, 0, 17, 148, 152, 219, 226, 3, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 800 +#[test] +fn c125_l800_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 5, 1, 112, 1, 2, 2, 9, 8, 1, 0, 65, 0, 11, 2, 0, 0]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l388_action_invoke(&mut instance); + c2_l389_action_invoke(&mut instance); + c3_l390_action_invoke(&mut instance); + c4_l391_action_invoke(&mut instance); + c5_l393_action_invoke(&mut instance); + c6_l395_action_invoke(&mut instance); + c7_l396_action_invoke(&mut instance); + c8_l397_action_invoke(&mut instance); + c9_l398_action_invoke(&mut instance); + c10_l400_action_invoke(&mut instance); + c11_l401_action_invoke(&mut instance); + c12_l402_action_invoke(&mut instance); + c13_l403_action_invoke(&mut instance); + c14_l405_action_invoke(&mut instance); + c15_l406_action_invoke(&mut instance); + c16_l407_action_invoke(&mut instance); + c17_l408_action_invoke(&mut instance); + c18_l409_action_invoke(&mut instance); + c19_l420_action_invoke(&mut instance); + c20_l421_action_invoke(&mut instance); + c21_l422_action_invoke(&mut instance); + c22_l423_action_invoke(&mut instance); + c23_l429_action_invoke(&mut instance); + c24_l430_action_invoke(&mut instance); + c25_l431_action_invoke(&mut instance); + c26_l432_action_invoke(&mut instance); + c27_l438_action_invoke(&mut instance); + c28_l439_action_invoke(&mut instance); + c29_l440_action_invoke(&mut instance); + c30_l441_action_invoke(&mut instance); + c31_l447_action_invoke(&mut instance); + c32_l448_action_invoke(&mut instance); + c33_l449_action_invoke(&mut instance); + c34_l450_action_invoke(&mut instance); + c35_l456_action_invoke(&mut instance); + c36_l457_action_invoke(&mut instance); + c37_l458_action_invoke(&mut instance); + c38_l459_action_invoke(&mut instance); + c39_l461_action_invoke(&mut instance); + c40_l462_action_invoke(&mut instance); + c41_l463_action_invoke(&mut instance); + c42_l464_action_invoke(&mut instance); + c43_l466_action_invoke(&mut instance); + c44_l467_action_invoke(&mut instance); + c45_l468_action_invoke(&mut instance); + c46_l469_action_invoke(&mut instance); + c47_l471_action_invoke(&mut instance); + c48_l472_action_invoke(&mut instance); + c49_l473_action_invoke(&mut instance); + c50_l474_action_invoke(&mut instance); + c51_l476_action_invoke(&mut instance); + c52_l477_action_invoke(&mut instance); + c53_l478_action_invoke(&mut instance); + c54_l479_action_invoke(&mut instance); + c55_l480_action_invoke(&mut instance); + c56_l482_action_invoke(&mut instance); + c57_l483_action_invoke(&mut instance); + c58_l484_action_invoke(&mut instance); + c59_l485_action_invoke(&mut instance); + c60_l486_action_invoke(&mut instance); + c61_l488_action_invoke(&mut instance); + c62_l489_action_invoke(&mut instance); + c63_l490_action_invoke(&mut instance); + c64_l491_action_invoke(&mut instance); + c65_l492_action_invoke(&mut instance); + c66_l494_action_invoke(&mut instance); + c67_l495_action_invoke(&mut instance); + c68_l496_action_invoke(&mut instance); + c69_l497_action_invoke(&mut instance); + c70_l498_action_invoke(&mut instance); + c71_l500_action_invoke(&mut instance); + c72_l501_action_invoke(&mut instance); + c73_l502_action_invoke(&mut instance); + c74_l503_action_invoke(&mut instance); + c75_l504_action_invoke(&mut instance); + c76_l505_action_invoke(&mut instance); + c77_l506_action_invoke(&mut instance); + c78_l507_action_invoke(&mut instance); + c81_l512_action_invoke(&mut instance); + c82_l513_action_invoke(&mut instance); + c83_l514_action_invoke(&mut instance); + c84_l516_action_invoke(&mut instance); + c85_l518_action_invoke(&mut instance); + c86_l519_action_invoke(&mut instance); + c87_l521_action_invoke(&mut instance); + c88_l522_action_invoke(&mut instance); + c89_l524_action_invoke(&mut instance); + c90_l525_action_invoke(&mut instance); + c91_l527_action_invoke(&mut instance); + c92_l528_action_invoke(&mut instance); + c93_l529_action_invoke(&mut instance); + c94_l530_action_invoke(&mut instance); + c95_l531_action_invoke(&mut instance); + c96_l532_action_invoke(&mut instance); + c97_l533_action_invoke(&mut instance); + c98_l534_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/comments.rs b/lib/runtime/tests/spectests/comments.rs new file mode 100644 index 000000000..0bd690b9c --- /dev/null +++ b/lib/runtime/tests/spectests/comments.rs @@ -0,0 +1,103 @@ +// 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/comments.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 10 +fn create_module_1() -> Box { + let module_str = "(module) + "; + 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 52 + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); +} +fn create_module_2() -> Box { + let module_str = "(module) + "; + 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_2(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 62 + +#[test] +fn test_module_2() { + let mut instance = create_module_2(); + // We group the calls together + start_module_2(&mut instance); +} +fn create_module_3() -> Box { + let module_str = "(module) + "; + 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_3(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 71 + +#[test] +fn test_module_3() { + let mut instance = create_module_3(); + // We group the calls together + start_module_3(&mut instance); +} +fn create_module_4() -> Box { + let module_str = "(module) + "; + 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_4(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +#[test] +fn test_module_4() { + let mut instance = create_module_4(); + // We group the calls together + start_module_4(&mut instance); +} diff --git a/lib/runtime/tests/spectests/const_.rs b/lib/runtime/tests/spectests/const_.rs new file mode 100644 index 000000000..1288750bf --- /dev/null +++ b/lib/runtime/tests/spectests/const_.rs @@ -0,0 +1,911 @@ +// 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/const_.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 5 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + i32.const -1 + drop)) + "; + 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 6 + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); +} +fn create_module_2() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + i32.const -2147483648 + drop)) + "; + 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_2(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 8 +#[test] +fn c2_l8_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 48, 48, 48, 48, 48, 48, 48, 48, 41, 32, 100, 114, 111, 112, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 12 +#[test] +fn c3_l12_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 45, 48, 120, 56, 48, 48, 48, 48, 48, 48, 49, 41, 32, 100, 114, 111, 112, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 16 + +#[test] +fn test_module_2() { + let mut instance = create_module_2(); + // We group the calls together + start_module_2(&mut instance); +} +fn create_module_3() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + i32.const -1 + drop)) + "; + 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_3(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 17 + +#[test] +fn test_module_3() { + let mut instance = create_module_3(); + // We group the calls together + start_module_3(&mut instance); +} +fn create_module_4() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + i32.const -2147483648 + drop)) + "; + 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_4(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 19 +#[test] +fn c6_l19_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 52, 50, 57, 52, 57, 54, 55, 50, 57, 54, 41, 32, 100, 114, 111, 112, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 23 +#[test] +fn c7_l23_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 45, 50, 49, 52, 55, 52, 56, 51, 54, 52, 57, 41, 32, 100, 114, 111, 112, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 27 + +#[test] +fn test_module_4() { + let mut instance = create_module_4(); + // We group the calls together + start_module_4(&mut instance); +} +fn create_module_5() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + i64.const -1 + drop)) + "; + 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_5(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 28 + +#[test] +fn test_module_5() { + let mut instance = create_module_5(); + // We group the calls together + start_module_5(&mut instance); +} +fn create_module_6() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + i64.const -9223372036854775808 + drop)) + "; + 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_6(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 30 +#[test] +fn c10_l30_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 41, 32, 100, 114, 111, 112, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 34 +#[test] +fn c11_l34_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 45, 48, 120, 56, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 49, 41, 32, 100, 114, 111, 112, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 38 + +#[test] +fn test_module_6() { + let mut instance = create_module_6(); + // We group the calls together + start_module_6(&mut instance); +} +fn create_module_7() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + i64.const -1 + drop)) + "; + 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_7(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 39 + +#[test] +fn test_module_7() { + let mut instance = create_module_7(); + // We group the calls together + start_module_7(&mut instance); +} +fn create_module_8() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + i64.const -9223372036854775808 + drop)) + "; + 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_8(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 41 +#[test] +fn c14_l41_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 49, 56, 52, 52, 54, 55, 52, 52, 48, 55, 51, 55, 48, 57, 53, 53, 49, 54, 49, 54, 41, 32, 100, 114, 111, 112, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 45 +#[test] +fn c15_l45_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 45, 57, 50, 50, 51, 51, 55, 50, 48, 51, 54, 56, 53, 52, 55, 55, 53, 56, 48, 57, 41, 32, 100, 114, 111, 112, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 49 + +#[test] +fn test_module_8() { + let mut instance = create_module_8(); + // We group the calls together + start_module_8(&mut instance); +} +fn create_module_9() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + f32.const 0x1p+127 (;=1.70141e+38;) + drop)) + "; + 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_9(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 50 + +#[test] +fn test_module_9() { + let mut instance = create_module_9(); + // We group the calls together + start_module_9(&mut instance); +} +fn create_module_10() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + f32.const -0x1p+127 (;=-1.70141e+38;) + drop)) + "; + 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_10(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 51 + +#[test] +fn test_module_10() { + let mut instance = create_module_10(); + // We group the calls together + start_module_10(&mut instance); +} +fn create_module_11() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + f32.const 0x1.fffffep+127 (;=3.40282e+38;) + drop)) + "; + 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_11(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 52 + +#[test] +fn test_module_11() { + let mut instance = create_module_11(); + // We group the calls together + start_module_11(&mut instance); +} +fn create_module_12() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + f32.const -0x1.fffffep+127 (;=-3.40282e+38;) + drop)) + "; + 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_12(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 53 + +#[test] +fn test_module_12() { + let mut instance = create_module_12(); + // We group the calls together + start_module_12(&mut instance); +} +fn create_module_13() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + f32.const 0x1.fffffep+127 (;=3.40282e+38;) + drop)) + "; + 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_13(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 54 + +#[test] +fn test_module_13() { + let mut instance = create_module_13(); + // We group the calls together + start_module_13(&mut instance); +} +fn create_module_14() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + f32.const -0x1.fffffep+127 (;=-3.40282e+38;) + drop)) + "; + 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_14(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 56 +#[test] +fn c22_l56_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 112, 49, 50, 56, 41, 32, 100, 114, 111, 112, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 60 +#[test] +fn c23_l60_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 45, 48, 120, 49, 112, 49, 50, 56, 41, 32, 100, 114, 111, 112, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 64 +#[test] +fn c24_l64_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 46, 102, 102, 102, 102, 102, 102, 112, 49, 50, 55, 41, 32, 100, 114, 111, 112, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 68 +#[test] +fn c25_l68_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 45, 48, 120, 49, 46, 102, 102, 102, 102, 102, 102, 112, 49, 50, 55, 41, 32, 100, 114, 111, 112, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 72 + +#[test] +fn test_module_14() { + let mut instance = create_module_14(); + // We group the calls together + start_module_14(&mut instance); +} +fn create_module_15() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + f32.const 0x1.2ced32p+126 (;=1e+38;) + drop)) + "; + 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_15(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 73 + +#[test] +fn test_module_15() { + let mut instance = create_module_15(); + // We group the calls together + start_module_15(&mut instance); +} +fn create_module_16() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + f32.const -0x1.2ced32p+126 (;=-1e+38;) + drop)) + "; + 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_16(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 75 +#[test] +fn c28_l75_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 49, 101, 51, 57, 41, 32, 100, 114, 111, 112, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 79 +#[test] +fn c29_l79_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 45, 49, 101, 51, 57, 41, 32, 100, 114, 111, 112, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 83 + +#[test] +fn test_module_16() { + let mut instance = create_module_16(); + // We group the calls together + start_module_16(&mut instance); +} +fn create_module_17() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + f32.const 0x1.fffffep+127 (;=3.40282e+38;) + drop)) + "; + 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_17(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 84 + +#[test] +fn test_module_17() { + let mut instance = create_module_17(); + // We group the calls together + start_module_17(&mut instance); +} +fn create_module_18() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + f32.const -0x1.fffffep+127 (;=-3.40282e+38;) + drop)) + "; + 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_18(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 86 +#[test] +fn c32_l86_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 51, 52, 48, 50, 56, 50, 51, 53, 54, 55, 55, 57, 55, 51, 51, 54, 54, 49, 54, 51, 55, 53, 51, 57, 51, 57, 53, 52, 53, 56, 49, 52, 50, 53, 54, 56, 52, 52, 56, 41, 32, 100, 114, 111, 112, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 90 +#[test] +fn c33_l90_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 45, 51, 52, 48, 50, 56, 50, 51, 53, 54, 55, 55, 57, 55, 51, 51, 54, 54, 49, 54, 51, 55, 53, 51, 57, 51, 57, 53, 52, 53, 56, 49, 52, 50, 53, 54, 56, 52, 52, 56, 41, 32, 100, 114, 111, 112, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 94 + +#[test] +fn test_module_18() { + let mut instance = create_module_18(); + // We group the calls together + start_module_18(&mut instance); +} +fn create_module_19() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + f64.const 0x1p+1023 (;=8.98847e+307;) + drop)) + "; + 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_19(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 95 + +#[test] +fn test_module_19() { + let mut instance = create_module_19(); + // We group the calls together + start_module_19(&mut instance); +} +fn create_module_20() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + f64.const -0x1p+1023 (;=-8.98847e+307;) + drop)) + "; + 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_20(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 96 + +#[test] +fn test_module_20() { + let mut instance = create_module_20(); + // We group the calls together + start_module_20(&mut instance); +} +fn create_module_21() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + f64.const 0x1.fffffffffffffp+1023 (;=1.79769e+308;) + drop)) + "; + 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_21(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 97 + +#[test] +fn test_module_21() { + let mut instance = create_module_21(); + // We group the calls together + start_module_21(&mut instance); +} +fn create_module_22() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + f64.const -0x1.fffffffffffffp+1023 (;=-1.79769e+308;) + drop)) + "; + 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_22(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 98 + +#[test] +fn test_module_22() { + let mut instance = create_module_22(); + // We group the calls together + start_module_22(&mut instance); +} +fn create_module_23() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + f64.const 0x1.fffffffffffffp+1023 (;=1.79769e+308;) + drop)) + "; + 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_23(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 99 + +#[test] +fn test_module_23() { + let mut instance = create_module_23(); + // We group the calls together + start_module_23(&mut instance); +} +fn create_module_24() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + f64.const -0x1.fffffffffffffp+1023 (;=-1.79769e+308;) + drop)) + "; + 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_24(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 101 +#[test] +fn c40_l101_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 112, 49, 48, 50, 52, 41, 32, 100, 114, 111, 112, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 105 +#[test] +fn c41_l105_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 45, 48, 120, 49, 112, 49, 48, 50, 52, 41, 32, 100, 114, 111, 112, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 109 +#[test] +fn c42_l109_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 46, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 56, 112, 49, 48, 50, 51, 41, 32, 100, 114, 111, 112, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 113 +#[test] +fn c43_l113_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 45, 48, 120, 49, 46, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 56, 112, 49, 48, 50, 51, 41, 32, 100, 114, 111, 112, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 117 + +#[test] +fn test_module_24() { + let mut instance = create_module_24(); + // We group the calls together + start_module_24(&mut instance); +} +fn create_module_25() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + f64.const 0x1.1ccf385ebc8ap+1023 (;=1e+308;) + drop)) + "; + 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_25(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 118 + +#[test] +fn test_module_25() { + let mut instance = create_module_25(); + // We group the calls together + start_module_25(&mut instance); +} +fn create_module_26() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + f64.const -0x1.1ccf385ebc8ap+1023 (;=-1e+308;) + drop)) + "; + 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_26(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 120 +#[test] +fn c46_l120_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 49, 101, 51, 48, 57, 41, 32, 100, 114, 111, 112, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 124 +#[test] +fn c47_l124_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 45, 49, 101, 51, 48, 57, 41, 32, 100, 114, 111, 112, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 128 + +#[test] +fn test_module_26() { + let mut instance = create_module_26(); + // We group the calls together + start_module_26(&mut instance); +} +fn create_module_27() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + f64.const 0x1.fffffffffffffp+1023 (;=1.79769e+308;) + drop)) + "; + 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_27(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 129 + +#[test] +fn test_module_27() { + let mut instance = create_module_27(); + // We group the calls together + start_module_27(&mut instance); +} +fn create_module_28() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0) + f64.const -0x1.fffffffffffffp+1023 (;=-1.79769e+308;) + drop)) + "; + 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_28(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 131 +#[test] +fn c50_l131_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 50, 54, 57, 54, 53, 51, 57, 55, 48, 50, 50, 57, 51, 52, 55, 51, 53, 54, 50, 50, 49, 55, 57, 49, 49, 51, 53, 53, 57, 55, 53, 53, 54, 53, 51, 53, 49, 57, 55, 49, 48, 53, 56, 53, 49, 50, 56, 56, 55, 54, 55, 52, 57, 52, 56, 57, 56, 51, 55, 54, 50, 49, 53, 50, 48, 52, 55, 51, 53, 56, 57, 49, 49, 55, 48, 48, 52, 50, 56, 48, 56, 49, 52, 48, 56, 56, 52, 51, 51, 55, 57, 52, 57, 49, 53, 48, 51, 49, 55, 50, 53, 55, 51, 49, 48, 54, 56, 56, 52, 51, 48, 50, 55, 49, 53, 55, 51, 54, 57, 54, 51, 53, 49, 52, 56, 49, 57, 57, 48, 51, 51, 52, 49, 57, 54, 50, 55, 52, 49, 53, 50, 55, 48, 49, 51, 50, 48, 48, 53, 53, 51, 48, 54, 50, 55, 53, 52, 55, 57, 48, 55, 52, 56, 54, 53, 56, 54, 52, 56, 50, 54, 57, 50, 51, 49, 49, 52, 51, 54, 56, 50, 51, 53, 49, 51, 53, 53, 56, 51, 57, 57, 51, 52, 49, 54, 49, 49, 51, 56, 48, 50, 55, 54, 50, 54, 56, 50, 55, 48, 48, 57, 49, 51, 52, 53, 54, 56, 55, 52, 56, 53, 53, 51, 53, 52, 56, 51, 52, 52, 50, 50, 50, 52, 56, 55, 49, 50, 56, 51, 56, 57, 57, 56, 49, 56, 53, 48, 50, 50, 52, 49, 50, 49, 57, 54, 55, 51, 57, 51, 48, 54, 50, 49, 55, 48, 56, 52, 55, 53, 51, 49, 48, 55, 50, 54, 53, 55, 55, 49, 51, 55, 56, 57, 52, 57, 56, 50, 49, 56, 55, 53, 54, 48, 54, 48, 51, 57, 50, 55, 54, 49, 56, 55, 50, 56, 55, 53, 53, 50, 41, 32, 100, 114, 111, 112, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 135 +#[test] +fn c51_l135_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 45, 50, 54, 57, 54, 53, 51, 57, 55, 48, 50, 50, 57, 51, 52, 55, 51, 53, 54, 50, 50, 49, 55, 57, 49, 49, 51, 53, 53, 57, 55, 53, 53, 54, 53, 51, 53, 49, 57, 55, 49, 48, 53, 56, 53, 49, 50, 56, 56, 55, 54, 55, 52, 57, 52, 56, 57, 56, 51, 55, 54, 50, 49, 53, 50, 48, 52, 55, 51, 53, 56, 57, 49, 49, 55, 48, 48, 52, 50, 56, 48, 56, 49, 52, 48, 56, 56, 52, 51, 51, 55, 57, 52, 57, 49, 53, 48, 51, 49, 55, 50, 53, 55, 51, 49, 48, 54, 56, 56, 52, 51, 48, 50, 55, 49, 53, 55, 51, 54, 57, 54, 51, 53, 49, 52, 56, 49, 57, 57, 48, 51, 51, 52, 49, 57, 54, 50, 55, 52, 49, 53, 50, 55, 48, 49, 51, 50, 48, 48, 53, 53, 51, 48, 54, 50, 55, 53, 52, 55, 57, 48, 55, 52, 56, 54, 53, 56, 54, 52, 56, 50, 54, 57, 50, 51, 49, 49, 52, 51, 54, 56, 50, 51, 53, 49, 51, 53, 53, 56, 51, 57, 57, 51, 52, 49, 54, 49, 49, 51, 56, 48, 50, 55, 54, 50, 54, 56, 50, 55, 48, 48, 57, 49, 51, 52, 53, 54, 56, 55, 52, 56, 53, 53, 51, 53, 52, 56, 51, 52, 52, 50, 50, 50, 52, 56, 55, 49, 50, 56, 51, 56, 57, 57, 56, 49, 56, 53, 48, 50, 50, 52, 49, 50, 49, 57, 54, 55, 51, 57, 51, 48, 54, 50, 49, 55, 48, 56, 52, 55, 53, 51, 49, 48, 55, 50, 54, 53, 55, 55, 49, 51, 55, 56, 57, 52, 57, 56, 50, 49, 56, 55, 53, 54, 48, 54, 48, 51, 57, 50, 55, 54, 49, 56, 55, 50, 56, 55, 53, 53, 50, 41, 32, 100, 114, 111, 112, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +#[test] +fn test_module_28() { + let mut instance = create_module_28(); + // We group the calls together + start_module_28(&mut instance); +} diff --git a/lib/runtime/tests/spectests/conversions.rs b/lib/runtime/tests/spectests/conversions.rs new file mode 100644 index 000000000..e787c96cb --- /dev/null +++ b/lib/runtime/tests/spectests/conversions.rs @@ -0,0 +1,4247 @@ +// 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/conversions.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 1 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func (param i32) (result i64))) + (type (;1;) (func (param i64) (result i32))) + (type (;2;) (func (param f32) (result i32))) + (type (;3;) (func (param f64) (result i32))) + (type (;4;) (func (param f32) (result i64))) + (type (;5;) (func (param f64) (result i64))) + (type (;6;) (func (param i32) (result f32))) + (type (;7;) (func (param i64) (result f32))) + (type (;8;) (func (param i32) (result f64))) + (type (;9;) (func (param i64) (result f64))) + (type (;10;) (func (param f32) (result f64))) + (type (;11;) (func (param f64) (result f32))) + (func (;0;) (type 0) (param i32) (result i64) + get_local 0 + i64.extend_s/i32) + (func (;1;) (type 0) (param i32) (result i64) + get_local 0 + i64.extend_u/i32) + (func (;2;) (type 1) (param i64) (result i32) + get_local 0 + i32.wrap/i64) + (func (;3;) (type 2) (param f32) (result i32) + get_local 0 + i32.trunc_s/f32) + (func (;4;) (type 2) (param f32) (result i32) + get_local 0 + i32.trunc_u/f32) + (func (;5;) (type 3) (param f64) (result i32) + get_local 0 + i32.trunc_s/f64) + (func (;6;) (type 3) (param f64) (result i32) + get_local 0 + i32.trunc_u/f64) + (func (;7;) (type 4) (param f32) (result i64) + get_local 0 + i64.trunc_s/f32) + (func (;8;) (type 4) (param f32) (result i64) + get_local 0 + i64.trunc_u/f32) + (func (;9;) (type 5) (param f64) (result i64) + get_local 0 + i64.trunc_s/f64) + (func (;10;) (type 5) (param f64) (result i64) + get_local 0 + i64.trunc_u/f64) + (func (;11;) (type 6) (param i32) (result f32) + get_local 0 + f32.convert_s/i32) + (func (;12;) (type 7) (param i64) (result f32) + get_local 0 + f32.convert_s/i64) + (func (;13;) (type 8) (param i32) (result f64) + get_local 0 + f64.convert_s/i32) + (func (;14;) (type 9) (param i64) (result f64) + get_local 0 + f64.convert_s/i64) + (func (;15;) (type 6) (param i32) (result f32) + get_local 0 + f32.convert_u/i32) + (func (;16;) (type 7) (param i64) (result f32) + get_local 0 + f32.convert_u/i64) + (func (;17;) (type 8) (param i32) (result f64) + get_local 0 + f64.convert_u/i32) + (func (;18;) (type 9) (param i64) (result f64) + get_local 0 + f64.convert_u/i64) + (func (;19;) (type 10) (param f32) (result f64) + get_local 0 + f64.promote/f32) + (func (;20;) (type 11) (param f64) (result f32) + get_local 0 + f32.demote/f64) + (func (;21;) (type 6) (param i32) (result f32) + get_local 0 + f32.reinterpret/i32) + (func (;22;) (type 9) (param i64) (result f64) + get_local 0 + f64.reinterpret/i64) + (func (;23;) (type 2) (param f32) (result i32) + get_local 0 + i32.reinterpret/f32) + (func (;24;) (type 5) (param f64) (result i64) + get_local 0 + i64.reinterpret/f64) + (export \"i64.extend_s_i32\" (func 0)) + (export \"i64.extend_u_i32\" (func 1)) + (export \"i32.wrap_i64\" (func 2)) + (export \"i32.trunc_s_f32\" (func 3)) + (export \"i32.trunc_u_f32\" (func 4)) + (export \"i32.trunc_s_f64\" (func 5)) + (export \"i32.trunc_u_f64\" (func 6)) + (export \"i64.trunc_s_f32\" (func 7)) + (export \"i64.trunc_u_f32\" (func 8)) + (export \"i64.trunc_s_f64\" (func 9)) + (export \"i64.trunc_u_f64\" (func 10)) + (export \"f32.convert_s_i32\" (func 11)) + (export \"f32.convert_s_i64\" (func 12)) + (export \"f64.convert_s_i32\" (func 13)) + (export \"f64.convert_s_i64\" (func 14)) + (export \"f32.convert_u_i32\" (func 15)) + (export \"f32.convert_u_i64\" (func 16)) + (export \"f64.convert_u_i32\" (func 17)) + (export \"f64.convert_u_i64\" (func 18)) + (export \"f64.promote_f32\" (func 19)) + (export \"f32.demote_f64\" (func 20)) + (export \"f32.reinterpret_i32\" (func 21)) + (export \"f64.reinterpret_i64\" (func 22)) + (export \"i32.reinterpret_f32\" (func 23)) + (export \"i64.reinterpret_f64\" (func 24))) + "; + 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 29 +fn c1_l29_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l29_action_invoke"); + let result = instance.call("i64.extend_s_i32", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 30 +fn c2_l30_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l30_action_invoke"); + let result = instance.call("i64.extend_s_i32", &[Value::I32(10000 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(10000 as i64)))); + result.map(|_| ()) +} + +// Line 31 +fn c3_l31_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l31_action_invoke"); + let result = instance.call("i64.extend_s_i32", &[Value::I32(-10000 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(-10000 as i64)))); + result.map(|_| ()) +} + +// Line 32 +fn c4_l32_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l32_action_invoke"); + let result = instance.call("i64.extend_s_i32", &[Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); + result.map(|_| ()) +} + +// Line 33 +fn c5_l33_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l33_action_invoke"); + let result = instance.call("i64.extend_s_i32", &[Value::I32(2147483647 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(2147483647 as i64)))); + result.map(|_| ()) +} + +// Line 34 +fn c6_l34_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l34_action_invoke"); + let result = instance.call("i64.extend_s_i32", &[Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(-2147483648 as i64)))); + result.map(|_| ()) +} + +// Line 36 +fn c7_l36_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l36_action_invoke"); + let result = instance.call("i64.extend_u_i32", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 37 +fn c8_l37_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l37_action_invoke"); + let result = instance.call("i64.extend_u_i32", &[Value::I32(10000 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(10000 as i64)))); + result.map(|_| ()) +} + +// Line 38 +fn c9_l38_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l38_action_invoke"); + let result = instance.call("i64.extend_u_i32", &[Value::I32(-10000 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(4294957296 as i64)))); + result.map(|_| ()) +} + +// Line 39 +fn c10_l39_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c10_l39_action_invoke"); + let result = instance.call("i64.extend_u_i32", &[Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(4294967295 as i64)))); + result.map(|_| ()) +} + +// Line 40 +fn c11_l40_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c11_l40_action_invoke"); + let result = instance.call("i64.extend_u_i32", &[Value::I32(2147483647 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(2147483647 as i64)))); + result.map(|_| ()) +} + +// Line 41 +fn c12_l41_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c12_l41_action_invoke"); + let result = instance.call("i64.extend_u_i32", &[Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(2147483648 as i64)))); + result.map(|_| ()) +} + +// Line 43 +fn c13_l43_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c13_l43_action_invoke"); + let result = instance.call("i32.wrap_i64", &[Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 44 +fn c14_l44_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c14_l44_action_invoke"); + let result = instance.call("i32.wrap_i64", &[Value::I64(-100000 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(-100000 as i32)))); + result.map(|_| ()) +} + +// Line 45 +fn c15_l45_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c15_l45_action_invoke"); + let result = instance.call("i32.wrap_i64", &[Value::I64(2147483648 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(-2147483648 as i32)))); + result.map(|_| ()) +} + +// Line 46 +fn c16_l46_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c16_l46_action_invoke"); + let result = instance.call("i32.wrap_i64", &[Value::I64(-2147483649 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(2147483647 as i32)))); + result.map(|_| ()) +} + +// Line 47 +fn c17_l47_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c17_l47_action_invoke"); + let result = instance.call("i32.wrap_i64", &[Value::I64(-4294967296 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 48 +fn c18_l48_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c18_l48_action_invoke"); + let result = instance.call("i32.wrap_i64", &[Value::I64(-4294967297 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 49 +fn c19_l49_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c19_l49_action_invoke"); + let result = instance.call("i32.wrap_i64", &[Value::I64(-4294967295 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 50 +fn c20_l50_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c20_l50_action_invoke"); + let result = instance.call("i32.wrap_i64", &[Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 51 +fn c21_l51_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c21_l51_action_invoke"); + let result = instance.call("i32.wrap_i64", &[Value::I64(1311768467463790320 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(-1698898192 as i32)))); + result.map(|_| ()) +} + +// Line 52 +fn c22_l52_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c22_l52_action_invoke"); + let result = instance.call("i32.wrap_i64", &[Value::I64(4294967295 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 53 +fn c23_l53_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c23_l53_action_invoke"); + let result = instance.call("i32.wrap_i64", &[Value::I64(4294967296 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 54 +fn c24_l54_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c24_l54_action_invoke"); + let result = instance.call("i32.wrap_i64", &[Value::I64(4294967297 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 56 +fn c25_l56_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c25_l56_action_invoke"); + let result = instance.call("i32.trunc_s_f32", &[Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 57 +fn c26_l57_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c26_l57_action_invoke"); + let result = instance.call("i32.trunc_s_f32", &[Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 58 +fn c27_l58_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c27_l58_action_invoke"); + let result = instance.call("i32.trunc_s_f32", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 59 +fn c28_l59_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c28_l59_action_invoke"); + let result = instance.call("i32.trunc_s_f32", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 60 +fn c29_l60_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c29_l60_action_invoke"); + let result = instance.call("i32.trunc_s_f32", &[Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 61 +fn c30_l61_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c30_l61_action_invoke"); + let result = instance.call("i32.trunc_s_f32", &[Value::F32((1.1f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 62 +fn c31_l62_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c31_l62_action_invoke"); + let result = instance.call("i32.trunc_s_f32", &[Value::F32((1.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 63 +fn c32_l63_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c32_l63_action_invoke"); + let result = instance.call("i32.trunc_s_f32", &[Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 64 +fn c33_l64_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c33_l64_action_invoke"); + let result = instance.call("i32.trunc_s_f32", &[Value::F32((-1.1f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 65 +fn c34_l65_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c34_l65_action_invoke"); + let result = instance.call("i32.trunc_s_f32", &[Value::F32((-1.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 66 +fn c35_l66_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c35_l66_action_invoke"); + let result = instance.call("i32.trunc_s_f32", &[Value::F32((-1.9f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 67 +fn c36_l67_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c36_l67_action_invoke"); + let result = instance.call("i32.trunc_s_f32", &[Value::F32((-2.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(-2 as i32)))); + result.map(|_| ()) +} + +// Line 68 +fn c37_l68_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c37_l68_action_invoke"); + let result = instance.call("i32.trunc_s_f32", &[Value::F32((2147483500.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(2147483520 as i32)))); + result.map(|_| ()) +} + +// Line 69 +fn c38_l69_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c38_l69_action_invoke"); + let result = instance.call("i32.trunc_s_f32", &[Value::F32((-2147483600.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(-2147483648 as i32)))); + result.map(|_| ()) +} + +// Line 70 +fn c39_l70_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c39_l70_action_invoke"); + let result = instance.call("i32.trunc_s_f32", &[Value::F32((2147483600.0f32).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c39_l70_assert_trap() { + let mut instance = create_module_1(); + let result = c39_l70_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 71 +fn c40_l71_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c40_l71_action_invoke"); + let result = instance.call("i32.trunc_s_f32", &[Value::F32((-2147484000.0f32).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c40_l71_assert_trap() { + let mut instance = create_module_1(); + let result = c40_l71_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 72 +fn c41_l72_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c41_l72_action_invoke"); + let result = instance.call("i32.trunc_s_f32", &[Value::F32(f32::INFINITY.to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c41_l72_assert_trap() { + let mut instance = create_module_1(); + let result = c41_l72_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 73 +fn c42_l73_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c42_l73_action_invoke"); + let result = instance.call("i32.trunc_s_f32", &[Value::F32(f32::NEG_INFINITY.to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c42_l73_assert_trap() { + let mut instance = create_module_1(); + let result = c42_l73_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 74 +fn c43_l74_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c43_l74_action_invoke"); + let result = instance.call("i32.trunc_s_f32", &[Value::F32(f32::from_bits(2143289344) as u32)]); + + result.map(|_| ()) +} + +#[test] +fn c43_l74_assert_trap() { + let mut instance = create_module_1(); + let result = c43_l74_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 75 +fn c44_l75_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c44_l75_action_invoke"); + let result = instance.call("i32.trunc_s_f32", &[Value::F32(f32::from_bits(2141192192) as u32)]); + + result.map(|_| ()) +} + +#[test] +fn c44_l75_assert_trap() { + let mut instance = create_module_1(); + let result = c44_l75_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 76 +fn c45_l76_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c45_l76_action_invoke"); + let result = instance.call("i32.trunc_s_f32", &[Value::F32(f32::from_bits(4290772992) as u32)]); + + result.map(|_| ()) +} + +#[test] +fn c45_l76_assert_trap() { + let mut instance = create_module_1(); + let result = c45_l76_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 77 +fn c46_l77_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c46_l77_action_invoke"); + let result = instance.call("i32.trunc_s_f32", &[Value::F32(f32::from_bits(4288675840) as u32)]); + + result.map(|_| ()) +} + +#[test] +fn c46_l77_assert_trap() { + let mut instance = create_module_1(); + let result = c46_l77_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 79 +fn c47_l79_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c47_l79_action_invoke"); + let result = instance.call("i32.trunc_u_f32", &[Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 80 +fn c48_l80_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c48_l80_action_invoke"); + let result = instance.call("i32.trunc_u_f32", &[Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 81 +fn c49_l81_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c49_l81_action_invoke"); + let result = instance.call("i32.trunc_u_f32", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 82 +fn c50_l82_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c50_l82_action_invoke"); + let result = instance.call("i32.trunc_u_f32", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 83 +fn c51_l83_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c51_l83_action_invoke"); + let result = instance.call("i32.trunc_u_f32", &[Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 84 +fn c52_l84_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c52_l84_action_invoke"); + let result = instance.call("i32.trunc_u_f32", &[Value::F32((1.1f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 85 +fn c53_l85_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c53_l85_action_invoke"); + let result = instance.call("i32.trunc_u_f32", &[Value::F32((1.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 86 +fn c54_l86_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c54_l86_action_invoke"); + let result = instance.call("i32.trunc_u_f32", &[Value::F32((1.9f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 87 +fn c55_l87_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c55_l87_action_invoke"); + let result = instance.call("i32.trunc_u_f32", &[Value::F32((2.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 88 +fn c56_l88_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c56_l88_action_invoke"); + let result = instance.call("i32.trunc_u_f32", &[Value::F32((2147483600.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(-2147483648 as i32)))); + result.map(|_| ()) +} + +// Line 89 +fn c57_l89_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c57_l89_action_invoke"); + let result = instance.call("i32.trunc_u_f32", &[Value::F32((4294967000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(-256 as i32)))); + result.map(|_| ()) +} + +// Line 90 +fn c58_l90_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c58_l90_action_invoke"); + let result = instance.call("i32.trunc_u_f32", &[Value::F32((-0.9f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 91 +fn c59_l91_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c59_l91_action_invoke"); + let result = instance.call("i32.trunc_u_f32", &[Value::F32((-0.99999994f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 92 +fn c60_l92_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c60_l92_action_invoke"); + let result = instance.call("i32.trunc_u_f32", &[Value::F32((4294967300.0f32).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c60_l92_assert_trap() { + let mut instance = create_module_1(); + let result = c60_l92_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 93 +fn c61_l93_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c61_l93_action_invoke"); + let result = instance.call("i32.trunc_u_f32", &[Value::F32((-1.0f32).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c61_l93_assert_trap() { + let mut instance = create_module_1(); + let result = c61_l93_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 94 +fn c62_l94_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c62_l94_action_invoke"); + let result = instance.call("i32.trunc_u_f32", &[Value::F32(f32::INFINITY.to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c62_l94_assert_trap() { + let mut instance = create_module_1(); + let result = c62_l94_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 95 +fn c63_l95_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c63_l95_action_invoke"); + let result = instance.call("i32.trunc_u_f32", &[Value::F32(f32::NEG_INFINITY.to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c63_l95_assert_trap() { + let mut instance = create_module_1(); + let result = c63_l95_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 96 +fn c64_l96_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c64_l96_action_invoke"); + let result = instance.call("i32.trunc_u_f32", &[Value::F32(f32::from_bits(2143289344) as u32)]); + + result.map(|_| ()) +} + +#[test] +fn c64_l96_assert_trap() { + let mut instance = create_module_1(); + let result = c64_l96_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 97 +fn c65_l97_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c65_l97_action_invoke"); + let result = instance.call("i32.trunc_u_f32", &[Value::F32(f32::from_bits(2141192192) as u32)]); + + result.map(|_| ()) +} + +#[test] +fn c65_l97_assert_trap() { + let mut instance = create_module_1(); + let result = c65_l97_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 98 +fn c66_l98_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c66_l98_action_invoke"); + let result = instance.call("i32.trunc_u_f32", &[Value::F32(f32::from_bits(4290772992) as u32)]); + + result.map(|_| ()) +} + +#[test] +fn c66_l98_assert_trap() { + let mut instance = create_module_1(); + let result = c66_l98_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 99 +fn c67_l99_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c67_l99_action_invoke"); + let result = instance.call("i32.trunc_u_f32", &[Value::F32(f32::from_bits(4288675840) as u32)]); + + result.map(|_| ()) +} + +#[test] +fn c67_l99_assert_trap() { + let mut instance = create_module_1(); + let result = c67_l99_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 101 +fn c68_l101_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c68_l101_action_invoke"); + let result = instance.call("i32.trunc_s_f64", &[Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 102 +fn c69_l102_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c69_l102_action_invoke"); + let result = instance.call("i32.trunc_s_f64", &[Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 103 +fn c70_l103_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c70_l103_action_invoke"); + let result = instance.call("i32.trunc_s_f64", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 104 +fn c71_l104_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c71_l104_action_invoke"); + let result = instance.call("i32.trunc_s_f64", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 105 +fn c72_l105_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c72_l105_action_invoke"); + let result = instance.call("i32.trunc_s_f64", &[Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 106 +fn c73_l106_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c73_l106_action_invoke"); + let result = instance.call("i32.trunc_s_f64", &[Value::F64((1.1f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 107 +fn c74_l107_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c74_l107_action_invoke"); + let result = instance.call("i32.trunc_s_f64", &[Value::F64((1.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 108 +fn c75_l108_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c75_l108_action_invoke"); + let result = instance.call("i32.trunc_s_f64", &[Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 109 +fn c76_l109_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c76_l109_action_invoke"); + let result = instance.call("i32.trunc_s_f64", &[Value::F64((-1.1f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 110 +fn c77_l110_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c77_l110_action_invoke"); + let result = instance.call("i32.trunc_s_f64", &[Value::F64((-1.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 111 +fn c78_l111_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c78_l111_action_invoke"); + let result = instance.call("i32.trunc_s_f64", &[Value::F64((-1.9f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 112 +fn c79_l112_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c79_l112_action_invoke"); + let result = instance.call("i32.trunc_s_f64", &[Value::F64((-2.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(-2 as i32)))); + result.map(|_| ()) +} + +// Line 113 +fn c80_l113_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c80_l113_action_invoke"); + let result = instance.call("i32.trunc_s_f64", &[Value::F64((2147483647.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(2147483647 as i32)))); + result.map(|_| ()) +} + +// Line 114 +fn c81_l114_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c81_l114_action_invoke"); + let result = instance.call("i32.trunc_s_f64", &[Value::F64((-2147483648.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(-2147483648 as i32)))); + result.map(|_| ()) +} + +// Line 115 +fn c82_l115_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c82_l115_action_invoke"); + let result = instance.call("i32.trunc_s_f64", &[Value::F64((2147483648.0f64).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c82_l115_assert_trap() { + let mut instance = create_module_1(); + let result = c82_l115_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 116 +fn c83_l116_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c83_l116_action_invoke"); + let result = instance.call("i32.trunc_s_f64", &[Value::F64((-2147483649.0f64).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c83_l116_assert_trap() { + let mut instance = create_module_1(); + let result = c83_l116_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 117 +fn c84_l117_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c84_l117_action_invoke"); + let result = instance.call("i32.trunc_s_f64", &[Value::F64(f64::INFINITY.to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c84_l117_assert_trap() { + let mut instance = create_module_1(); + let result = c84_l117_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 118 +fn c85_l118_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c85_l118_action_invoke"); + let result = instance.call("i32.trunc_s_f64", &[Value::F64(f64::NEG_INFINITY.to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c85_l118_assert_trap() { + let mut instance = create_module_1(); + let result = c85_l118_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 119 +fn c86_l119_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c86_l119_action_invoke"); + let result = instance.call("i32.trunc_s_f64", &[Value::F64(f64::from_bits(9221120237041090560) as u64)]); + + result.map(|_| ()) +} + +#[test] +fn c86_l119_assert_trap() { + let mut instance = create_module_1(); + let result = c86_l119_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 120 +fn c87_l120_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c87_l120_action_invoke"); + let result = instance.call("i32.trunc_s_f64", &[Value::F64(f64::from_bits(9219994337134247936) as u64)]); + + result.map(|_| ()) +} + +#[test] +fn c87_l120_assert_trap() { + let mut instance = create_module_1(); + let result = c87_l120_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 121 +fn c88_l121_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c88_l121_action_invoke"); + let result = instance.call("i32.trunc_s_f64", &[Value::F64(f64::from_bits(18444492273895866368) as u64)]); + + result.map(|_| ()) +} + +#[test] +fn c88_l121_assert_trap() { + let mut instance = create_module_1(); + let result = c88_l121_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 122 +fn c89_l122_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c89_l122_action_invoke"); + let result = instance.call("i32.trunc_s_f64", &[Value::F64(f64::from_bits(18443366373989023744) as u64)]); + + result.map(|_| ()) +} + +#[test] +fn c89_l122_assert_trap() { + let mut instance = create_module_1(); + let result = c89_l122_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 124 +fn c90_l124_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c90_l124_action_invoke"); + let result = instance.call("i32.trunc_u_f64", &[Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 125 +fn c91_l125_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c91_l125_action_invoke"); + let result = instance.call("i32.trunc_u_f64", &[Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 126 +fn c92_l126_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c92_l126_action_invoke"); + let result = instance.call("i32.trunc_u_f64", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 127 +fn c93_l127_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c93_l127_action_invoke"); + let result = instance.call("i32.trunc_u_f64", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 128 +fn c94_l128_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c94_l128_action_invoke"); + let result = instance.call("i32.trunc_u_f64", &[Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 129 +fn c95_l129_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c95_l129_action_invoke"); + let result = instance.call("i32.trunc_u_f64", &[Value::F64((1.1f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 130 +fn c96_l130_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c96_l130_action_invoke"); + let result = instance.call("i32.trunc_u_f64", &[Value::F64((1.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 131 +fn c97_l131_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c97_l131_action_invoke"); + let result = instance.call("i32.trunc_u_f64", &[Value::F64((1.9f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 132 +fn c98_l132_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c98_l132_action_invoke"); + let result = instance.call("i32.trunc_u_f64", &[Value::F64((2.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 133 +fn c99_l133_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c99_l133_action_invoke"); + let result = instance.call("i32.trunc_u_f64", &[Value::F64((2147483648.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(-2147483648 as i32)))); + result.map(|_| ()) +} + +// Line 134 +fn c100_l134_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c100_l134_action_invoke"); + let result = instance.call("i32.trunc_u_f64", &[Value::F64((4294967295.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 135 +fn c101_l135_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c101_l135_action_invoke"); + let result = instance.call("i32.trunc_u_f64", &[Value::F64((-0.9f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 136 +fn c102_l136_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c102_l136_action_invoke"); + let result = instance.call("i32.trunc_u_f64", &[Value::F64((-0.9999999999999999f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 137 +fn c103_l137_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c103_l137_action_invoke"); + let result = instance.call("i32.trunc_u_f64", &[Value::F64((100000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(100000000 as i32)))); + result.map(|_| ()) +} + +// Line 138 +fn c104_l138_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c104_l138_action_invoke"); + let result = instance.call("i32.trunc_u_f64", &[Value::F64((4294967296.0f64).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c104_l138_assert_trap() { + let mut instance = create_module_1(); + let result = c104_l138_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 139 +fn c105_l139_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c105_l139_action_invoke"); + let result = instance.call("i32.trunc_u_f64", &[Value::F64((-1.0f64).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c105_l139_assert_trap() { + let mut instance = create_module_1(); + let result = c105_l139_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 140 +fn c106_l140_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c106_l140_action_invoke"); + let result = instance.call("i32.trunc_u_f64", &[Value::F64((10000000000000000.0f64).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c106_l140_assert_trap() { + let mut instance = create_module_1(); + let result = c106_l140_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 141 +fn c107_l141_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c107_l141_action_invoke"); + let result = instance.call("i32.trunc_u_f64", &[Value::F64((1000000000000000000000000000000.0f64).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c107_l141_assert_trap() { + let mut instance = create_module_1(); + let result = c107_l141_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 142 +fn c108_l142_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c108_l142_action_invoke"); + let result = instance.call("i32.trunc_u_f64", &[Value::F64((9223372036854776000.0f64).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c108_l142_assert_trap() { + let mut instance = create_module_1(); + let result = c108_l142_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 143 +fn c109_l143_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c109_l143_action_invoke"); + let result = instance.call("i32.trunc_u_f64", &[Value::F64(f64::INFINITY.to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c109_l143_assert_trap() { + let mut instance = create_module_1(); + let result = c109_l143_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 144 +fn c110_l144_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c110_l144_action_invoke"); + let result = instance.call("i32.trunc_u_f64", &[Value::F64(f64::NEG_INFINITY.to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c110_l144_assert_trap() { + let mut instance = create_module_1(); + let result = c110_l144_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 145 +fn c111_l145_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c111_l145_action_invoke"); + let result = instance.call("i32.trunc_u_f64", &[Value::F64(f64::from_bits(9221120237041090560) as u64)]); + + result.map(|_| ()) +} + +#[test] +fn c111_l145_assert_trap() { + let mut instance = create_module_1(); + let result = c111_l145_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 146 +fn c112_l146_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c112_l146_action_invoke"); + let result = instance.call("i32.trunc_u_f64", &[Value::F64(f64::from_bits(9219994337134247936) as u64)]); + + result.map(|_| ()) +} + +#[test] +fn c112_l146_assert_trap() { + let mut instance = create_module_1(); + let result = c112_l146_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 147 +fn c113_l147_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c113_l147_action_invoke"); + let result = instance.call("i32.trunc_u_f64", &[Value::F64(f64::from_bits(18444492273895866368) as u64)]); + + result.map(|_| ()) +} + +#[test] +fn c113_l147_assert_trap() { + let mut instance = create_module_1(); + let result = c113_l147_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 148 +fn c114_l148_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c114_l148_action_invoke"); + let result = instance.call("i32.trunc_u_f64", &[Value::F64(f64::from_bits(18443366373989023744) as u64)]); + + result.map(|_| ()) +} + +#[test] +fn c114_l148_assert_trap() { + let mut instance = create_module_1(); + let result = c114_l148_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 150 +fn c115_l150_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c115_l150_action_invoke"); + let result = instance.call("i64.trunc_s_f32", &[Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 151 +fn c116_l151_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c116_l151_action_invoke"); + let result = instance.call("i64.trunc_s_f32", &[Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 152 +fn c117_l152_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c117_l152_action_invoke"); + let result = instance.call("i64.trunc_s_f32", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 153 +fn c118_l153_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c118_l153_action_invoke"); + let result = instance.call("i64.trunc_s_f32", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 154 +fn c119_l154_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c119_l154_action_invoke"); + let result = instance.call("i64.trunc_s_f32", &[Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 155 +fn c120_l155_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c120_l155_action_invoke"); + let result = instance.call("i64.trunc_s_f32", &[Value::F32((1.1f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 156 +fn c121_l156_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c121_l156_action_invoke"); + let result = instance.call("i64.trunc_s_f32", &[Value::F32((1.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 157 +fn c122_l157_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c122_l157_action_invoke"); + let result = instance.call("i64.trunc_s_f32", &[Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); + result.map(|_| ()) +} + +// Line 158 +fn c123_l158_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c123_l158_action_invoke"); + let result = instance.call("i64.trunc_s_f32", &[Value::F32((-1.1f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); + result.map(|_| ()) +} + +// Line 159 +fn c124_l159_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c124_l159_action_invoke"); + let result = instance.call("i64.trunc_s_f32", &[Value::F32((-1.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); + result.map(|_| ()) +} + +// Line 160 +fn c125_l160_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c125_l160_action_invoke"); + let result = instance.call("i64.trunc_s_f32", &[Value::F32((-1.9f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); + result.map(|_| ()) +} + +// Line 161 +fn c126_l161_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c126_l161_action_invoke"); + let result = instance.call("i64.trunc_s_f32", &[Value::F32((-2.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(-2 as i64)))); + result.map(|_| ()) +} + +// Line 162 +fn c127_l162_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c127_l162_action_invoke"); + let result = instance.call("i64.trunc_s_f32", &[Value::F32((4294967300.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(4294967296 as i64)))); + result.map(|_| ()) +} + +// Line 163 +fn c128_l163_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c128_l163_action_invoke"); + let result = instance.call("i64.trunc_s_f32", &[Value::F32((-4294967300.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(-4294967296 as i64)))); + result.map(|_| ()) +} + +// Line 164 +fn c129_l164_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c129_l164_action_invoke"); + let result = instance.call("i64.trunc_s_f32", &[Value::F32((9223371500000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(9223371487098961920 as i64)))); + result.map(|_| ()) +} + +// Line 165 +fn c130_l165_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c130_l165_action_invoke"); + let result = instance.call("i64.trunc_s_f32", &[Value::F32((-9223372000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(-9223372036854775808 as i64)))); + result.map(|_| ()) +} + +// Line 166 +fn c131_l166_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c131_l166_action_invoke"); + let result = instance.call("i64.trunc_s_f32", &[Value::F32((9223372000000000000.0f32).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c131_l166_assert_trap() { + let mut instance = create_module_1(); + let result = c131_l166_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 167 +fn c132_l167_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c132_l167_action_invoke"); + let result = instance.call("i64.trunc_s_f32", &[Value::F32((-9223373000000000000.0f32).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c132_l167_assert_trap() { + let mut instance = create_module_1(); + let result = c132_l167_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 168 +fn c133_l168_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c133_l168_action_invoke"); + let result = instance.call("i64.trunc_s_f32", &[Value::F32(f32::INFINITY.to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c133_l168_assert_trap() { + let mut instance = create_module_1(); + let result = c133_l168_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 169 +fn c134_l169_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c134_l169_action_invoke"); + let result = instance.call("i64.trunc_s_f32", &[Value::F32(f32::NEG_INFINITY.to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c134_l169_assert_trap() { + let mut instance = create_module_1(); + let result = c134_l169_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 170 +fn c135_l170_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c135_l170_action_invoke"); + let result = instance.call("i64.trunc_s_f32", &[Value::F32(f32::from_bits(2143289344) as u32)]); + + result.map(|_| ()) +} + +#[test] +fn c135_l170_assert_trap() { + let mut instance = create_module_1(); + let result = c135_l170_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 171 +fn c136_l171_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c136_l171_action_invoke"); + let result = instance.call("i64.trunc_s_f32", &[Value::F32(f32::from_bits(2141192192) as u32)]); + + result.map(|_| ()) +} + +#[test] +fn c136_l171_assert_trap() { + let mut instance = create_module_1(); + let result = c136_l171_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 172 +fn c137_l172_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c137_l172_action_invoke"); + let result = instance.call("i64.trunc_s_f32", &[Value::F32(f32::from_bits(4290772992) as u32)]); + + result.map(|_| ()) +} + +#[test] +fn c137_l172_assert_trap() { + let mut instance = create_module_1(); + let result = c137_l172_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 173 +fn c138_l173_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c138_l173_action_invoke"); + let result = instance.call("i64.trunc_s_f32", &[Value::F32(f32::from_bits(4288675840) as u32)]); + + result.map(|_| ()) +} + +#[test] +fn c138_l173_assert_trap() { + let mut instance = create_module_1(); + let result = c138_l173_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 175 +fn c139_l175_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c139_l175_action_invoke"); + let result = instance.call("i64.trunc_u_f32", &[Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 176 +fn c140_l176_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c140_l176_action_invoke"); + let result = instance.call("i64.trunc_u_f32", &[Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 177 +fn c141_l177_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c141_l177_action_invoke"); + let result = instance.call("i64.trunc_u_f32", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 178 +fn c142_l178_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c142_l178_action_invoke"); + let result = instance.call("i64.trunc_u_f32", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 179 +fn c143_l179_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c143_l179_action_invoke"); + let result = instance.call("i64.trunc_u_f32", &[Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 180 +fn c144_l180_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c144_l180_action_invoke"); + let result = instance.call("i64.trunc_u_f32", &[Value::F32((1.1f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 181 +fn c145_l181_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c145_l181_action_invoke"); + let result = instance.call("i64.trunc_u_f32", &[Value::F32((1.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 182 +fn c146_l182_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c146_l182_action_invoke"); + let result = instance.call("i64.trunc_u_f32", &[Value::F32((4294967300.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(4294967296 as i64)))); + result.map(|_| ()) +} + +// Line 183 +fn c147_l183_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c147_l183_action_invoke"); + let result = instance.call("i64.trunc_u_f32", &[Value::F32((18446743000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(-1099511627776 as i64)))); + result.map(|_| ()) +} + +// Line 184 +fn c148_l184_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c148_l184_action_invoke"); + let result = instance.call("i64.trunc_u_f32", &[Value::F32((-0.9f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 185 +fn c149_l185_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c149_l185_action_invoke"); + let result = instance.call("i64.trunc_u_f32", &[Value::F32((-0.99999994f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 186 +fn c150_l186_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c150_l186_action_invoke"); + let result = instance.call("i64.trunc_u_f32", &[Value::F32((18446744000000000000.0f32).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c150_l186_assert_trap() { + let mut instance = create_module_1(); + let result = c150_l186_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 187 +fn c151_l187_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c151_l187_action_invoke"); + let result = instance.call("i64.trunc_u_f32", &[Value::F32((-1.0f32).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c151_l187_assert_trap() { + let mut instance = create_module_1(); + let result = c151_l187_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 188 +fn c152_l188_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c152_l188_action_invoke"); + let result = instance.call("i64.trunc_u_f32", &[Value::F32(f32::INFINITY.to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c152_l188_assert_trap() { + let mut instance = create_module_1(); + let result = c152_l188_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 189 +fn c153_l189_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c153_l189_action_invoke"); + let result = instance.call("i64.trunc_u_f32", &[Value::F32(f32::NEG_INFINITY.to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c153_l189_assert_trap() { + let mut instance = create_module_1(); + let result = c153_l189_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 190 +fn c154_l190_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c154_l190_action_invoke"); + let result = instance.call("i64.trunc_u_f32", &[Value::F32(f32::from_bits(2143289344) as u32)]); + + result.map(|_| ()) +} + +#[test] +fn c154_l190_assert_trap() { + let mut instance = create_module_1(); + let result = c154_l190_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 191 +fn c155_l191_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c155_l191_action_invoke"); + let result = instance.call("i64.trunc_u_f32", &[Value::F32(f32::from_bits(2141192192) as u32)]); + + result.map(|_| ()) +} + +#[test] +fn c155_l191_assert_trap() { + let mut instance = create_module_1(); + let result = c155_l191_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 192 +fn c156_l192_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c156_l192_action_invoke"); + let result = instance.call("i64.trunc_u_f32", &[Value::F32(f32::from_bits(4290772992) as u32)]); + + result.map(|_| ()) +} + +#[test] +fn c156_l192_assert_trap() { + let mut instance = create_module_1(); + let result = c156_l192_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 193 +fn c157_l193_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c157_l193_action_invoke"); + let result = instance.call("i64.trunc_u_f32", &[Value::F32(f32::from_bits(4288675840) as u32)]); + + result.map(|_| ()) +} + +#[test] +fn c157_l193_assert_trap() { + let mut instance = create_module_1(); + let result = c157_l193_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 195 +fn c158_l195_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c158_l195_action_invoke"); + let result = instance.call("i64.trunc_s_f64", &[Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 196 +fn c159_l196_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c159_l196_action_invoke"); + let result = instance.call("i64.trunc_s_f64", &[Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 197 +fn c160_l197_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c160_l197_action_invoke"); + let result = instance.call("i64.trunc_s_f64", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 198 +fn c161_l198_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c161_l198_action_invoke"); + let result = instance.call("i64.trunc_s_f64", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 199 +fn c162_l199_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c162_l199_action_invoke"); + let result = instance.call("i64.trunc_s_f64", &[Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 200 +fn c163_l200_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c163_l200_action_invoke"); + let result = instance.call("i64.trunc_s_f64", &[Value::F64((1.1f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 201 +fn c164_l201_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c164_l201_action_invoke"); + let result = instance.call("i64.trunc_s_f64", &[Value::F64((1.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 202 +fn c165_l202_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c165_l202_action_invoke"); + let result = instance.call("i64.trunc_s_f64", &[Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); + result.map(|_| ()) +} + +// Line 203 +fn c166_l203_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c166_l203_action_invoke"); + let result = instance.call("i64.trunc_s_f64", &[Value::F64((-1.1f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); + result.map(|_| ()) +} + +// Line 204 +fn c167_l204_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c167_l204_action_invoke"); + let result = instance.call("i64.trunc_s_f64", &[Value::F64((-1.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); + result.map(|_| ()) +} + +// Line 205 +fn c168_l205_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c168_l205_action_invoke"); + let result = instance.call("i64.trunc_s_f64", &[Value::F64((-1.9f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); + result.map(|_| ()) +} + +// Line 206 +fn c169_l206_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c169_l206_action_invoke"); + let result = instance.call("i64.trunc_s_f64", &[Value::F64((-2.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(-2 as i64)))); + result.map(|_| ()) +} + +// Line 207 +fn c170_l207_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c170_l207_action_invoke"); + let result = instance.call("i64.trunc_s_f64", &[Value::F64((4294967296.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(4294967296 as i64)))); + result.map(|_| ()) +} + +// Line 208 +fn c171_l208_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c171_l208_action_invoke"); + let result = instance.call("i64.trunc_s_f64", &[Value::F64((-4294967296.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(-4294967296 as i64)))); + result.map(|_| ()) +} + +// Line 209 +fn c172_l209_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c172_l209_action_invoke"); + let result = instance.call("i64.trunc_s_f64", &[Value::F64((9223372036854775000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(9223372036854774784 as i64)))); + result.map(|_| ()) +} + +// Line 210 +fn c173_l210_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c173_l210_action_invoke"); + let result = instance.call("i64.trunc_s_f64", &[Value::F64((-9223372036854776000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(-9223372036854775808 as i64)))); + result.map(|_| ()) +} + +// Line 211 +fn c174_l211_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c174_l211_action_invoke"); + let result = instance.call("i64.trunc_s_f64", &[Value::F64((9223372036854776000.0f64).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c174_l211_assert_trap() { + let mut instance = create_module_1(); + let result = c174_l211_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 212 +fn c175_l212_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c175_l212_action_invoke"); + let result = instance.call("i64.trunc_s_f64", &[Value::F64((-9223372036854778000.0f64).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c175_l212_assert_trap() { + let mut instance = create_module_1(); + let result = c175_l212_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 213 +fn c176_l213_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c176_l213_action_invoke"); + let result = instance.call("i64.trunc_s_f64", &[Value::F64(f64::INFINITY.to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c176_l213_assert_trap() { + let mut instance = create_module_1(); + let result = c176_l213_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 214 +fn c177_l214_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c177_l214_action_invoke"); + let result = instance.call("i64.trunc_s_f64", &[Value::F64(f64::NEG_INFINITY.to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c177_l214_assert_trap() { + let mut instance = create_module_1(); + let result = c177_l214_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 215 +fn c178_l215_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c178_l215_action_invoke"); + let result = instance.call("i64.trunc_s_f64", &[Value::F64(f64::from_bits(9221120237041090560) as u64)]); + + result.map(|_| ()) +} + +#[test] +fn c178_l215_assert_trap() { + let mut instance = create_module_1(); + let result = c178_l215_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 216 +fn c179_l216_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c179_l216_action_invoke"); + let result = instance.call("i64.trunc_s_f64", &[Value::F64(f64::from_bits(9219994337134247936) as u64)]); + + result.map(|_| ()) +} + +#[test] +fn c179_l216_assert_trap() { + let mut instance = create_module_1(); + let result = c179_l216_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 217 +fn c180_l217_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c180_l217_action_invoke"); + let result = instance.call("i64.trunc_s_f64", &[Value::F64(f64::from_bits(18444492273895866368) as u64)]); + + result.map(|_| ()) +} + +#[test] +fn c180_l217_assert_trap() { + let mut instance = create_module_1(); + let result = c180_l217_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 218 +fn c181_l218_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c181_l218_action_invoke"); + let result = instance.call("i64.trunc_s_f64", &[Value::F64(f64::from_bits(18443366373989023744) as u64)]); + + result.map(|_| ()) +} + +#[test] +fn c181_l218_assert_trap() { + let mut instance = create_module_1(); + let result = c181_l218_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 220 +fn c182_l220_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c182_l220_action_invoke"); + let result = instance.call("i64.trunc_u_f64", &[Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 221 +fn c183_l221_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c183_l221_action_invoke"); + let result = instance.call("i64.trunc_u_f64", &[Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 222 +fn c184_l222_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c184_l222_action_invoke"); + let result = instance.call("i64.trunc_u_f64", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 223 +fn c185_l223_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c185_l223_action_invoke"); + let result = instance.call("i64.trunc_u_f64", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 224 +fn c186_l224_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c186_l224_action_invoke"); + let result = instance.call("i64.trunc_u_f64", &[Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 225 +fn c187_l225_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c187_l225_action_invoke"); + let result = instance.call("i64.trunc_u_f64", &[Value::F64((1.1f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 226 +fn c188_l226_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c188_l226_action_invoke"); + let result = instance.call("i64.trunc_u_f64", &[Value::F64((1.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 227 +fn c189_l227_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c189_l227_action_invoke"); + let result = instance.call("i64.trunc_u_f64", &[Value::F64((4294967295.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(4294967295 as i64)))); + result.map(|_| ()) +} + +// Line 228 +fn c190_l228_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c190_l228_action_invoke"); + let result = instance.call("i64.trunc_u_f64", &[Value::F64((4294967296.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(4294967296 as i64)))); + result.map(|_| ()) +} + +// Line 229 +fn c191_l229_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c191_l229_action_invoke"); + let result = instance.call("i64.trunc_u_f64", &[Value::F64((18446744073709550000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(-2048 as i64)))); + result.map(|_| ()) +} + +// Line 230 +fn c192_l230_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c192_l230_action_invoke"); + let result = instance.call("i64.trunc_u_f64", &[Value::F64((-0.9f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 231 +fn c193_l231_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c193_l231_action_invoke"); + let result = instance.call("i64.trunc_u_f64", &[Value::F64((-0.9999999999999999f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 232 +fn c194_l232_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c194_l232_action_invoke"); + let result = instance.call("i64.trunc_u_f64", &[Value::F64((100000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(100000000 as i64)))); + result.map(|_| ()) +} + +// Line 233 +fn c195_l233_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c195_l233_action_invoke"); + let result = instance.call("i64.trunc_u_f64", &[Value::F64((10000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(10000000000000000 as i64)))); + result.map(|_| ()) +} + +// Line 234 +fn c196_l234_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c196_l234_action_invoke"); + let result = instance.call("i64.trunc_u_f64", &[Value::F64((9223372036854776000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(-9223372036854775808 as i64)))); + result.map(|_| ()) +} + +// Line 235 +fn c197_l235_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c197_l235_action_invoke"); + let result = instance.call("i64.trunc_u_f64", &[Value::F64((18446744073709552000.0f64).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c197_l235_assert_trap() { + let mut instance = create_module_1(); + let result = c197_l235_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 236 +fn c198_l236_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c198_l236_action_invoke"); + let result = instance.call("i64.trunc_u_f64", &[Value::F64((-1.0f64).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c198_l236_assert_trap() { + let mut instance = create_module_1(); + let result = c198_l236_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 237 +fn c199_l237_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c199_l237_action_invoke"); + let result = instance.call("i64.trunc_u_f64", &[Value::F64(f64::INFINITY.to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c199_l237_assert_trap() { + let mut instance = create_module_1(); + let result = c199_l237_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 238 +fn c200_l238_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c200_l238_action_invoke"); + let result = instance.call("i64.trunc_u_f64", &[Value::F64(f64::NEG_INFINITY.to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c200_l238_assert_trap() { + let mut instance = create_module_1(); + let result = c200_l238_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 239 +fn c201_l239_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c201_l239_action_invoke"); + let result = instance.call("i64.trunc_u_f64", &[Value::F64(f64::from_bits(9221120237041090560) as u64)]); + + result.map(|_| ()) +} + +#[test] +fn c201_l239_assert_trap() { + let mut instance = create_module_1(); + let result = c201_l239_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 240 +fn c202_l240_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c202_l240_action_invoke"); + let result = instance.call("i64.trunc_u_f64", &[Value::F64(f64::from_bits(9219994337134247936) as u64)]); + + result.map(|_| ()) +} + +#[test] +fn c202_l240_assert_trap() { + let mut instance = create_module_1(); + let result = c202_l240_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 241 +fn c203_l241_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c203_l241_action_invoke"); + let result = instance.call("i64.trunc_u_f64", &[Value::F64(f64::from_bits(18444492273895866368) as u64)]); + + result.map(|_| ()) +} + +#[test] +fn c203_l241_assert_trap() { + let mut instance = create_module_1(); + let result = c203_l241_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 242 +fn c204_l242_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c204_l242_action_invoke"); + let result = instance.call("i64.trunc_u_f64", &[Value::F64(f64::from_bits(18443366373989023744) as u64)]); + + result.map(|_| ()) +} + +#[test] +fn c204_l242_assert_trap() { + let mut instance = create_module_1(); + let result = c204_l242_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 244 +fn c205_l244_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c205_l244_action_invoke"); + let result = instance.call("f32.convert_s_i32", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 245 +fn c206_l245_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c206_l245_action_invoke"); + let result = instance.call("f32.convert_s_i32", &[Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 246 +fn c207_l246_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c207_l246_action_invoke"); + let result = instance.call("f32.convert_s_i32", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 247 +fn c208_l247_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c208_l247_action_invoke"); + let result = instance.call("f32.convert_s_i32", &[Value::I32(2147483647 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((2147483600.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 248 +fn c209_l248_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c209_l248_action_invoke"); + let result = instance.call("f32.convert_s_i32", &[Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((-2147483600.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 249 +fn c210_l249_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c210_l249_action_invoke"); + let result = instance.call("f32.convert_s_i32", &[Value::I32(1234567890 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((1234568000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 251 +fn c211_l251_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c211_l251_action_invoke"); + let result = instance.call("f32.convert_s_i32", &[Value::I32(16777217 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((16777216.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 252 +fn c212_l252_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c212_l252_action_invoke"); + let result = instance.call("f32.convert_s_i32", &[Value::I32(-16777217 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((-16777216.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 253 +fn c213_l253_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c213_l253_action_invoke"); + let result = instance.call("f32.convert_s_i32", &[Value::I32(16777219 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((16777220.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 254 +fn c214_l254_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c214_l254_action_invoke"); + let result = instance.call("f32.convert_s_i32", &[Value::I32(-16777219 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((-16777220.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 256 +fn c215_l256_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c215_l256_action_invoke"); + let result = instance.call("f32.convert_s_i64", &[Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 257 +fn c216_l257_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c216_l257_action_invoke"); + let result = instance.call("f32.convert_s_i64", &[Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 258 +fn c217_l258_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c217_l258_action_invoke"); + let result = instance.call("f32.convert_s_i64", &[Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 259 +fn c218_l259_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c218_l259_action_invoke"); + let result = instance.call("f32.convert_s_i64", &[Value::I64(9223372036854775807 as i64)]); + assert_eq!(result, Ok(Some(Value::F32((9223372000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 260 +fn c219_l260_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c219_l260_action_invoke"); + let result = instance.call("f32.convert_s_i64", &[Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::F32((-9223372000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 261 +fn c220_l261_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c220_l261_action_invoke"); + let result = instance.call("f32.convert_s_i64", &[Value::I64(314159265358979 as i64)]); + assert_eq!(result, Ok(Some(Value::F32((314159280000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 263 +fn c221_l263_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c221_l263_action_invoke"); + let result = instance.call("f32.convert_s_i64", &[Value::I64(16777217 as i64)]); + assert_eq!(result, Ok(Some(Value::F32((16777216.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 264 +fn c222_l264_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c222_l264_action_invoke"); + let result = instance.call("f32.convert_s_i64", &[Value::I64(-16777217 as i64)]); + assert_eq!(result, Ok(Some(Value::F32((-16777216.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 265 +fn c223_l265_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c223_l265_action_invoke"); + let result = instance.call("f32.convert_s_i64", &[Value::I64(16777219 as i64)]); + assert_eq!(result, Ok(Some(Value::F32((16777220.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 266 +fn c224_l266_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c224_l266_action_invoke"); + let result = instance.call("f32.convert_s_i64", &[Value::I64(-16777219 as i64)]); + assert_eq!(result, Ok(Some(Value::F32((-16777220.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 268 +fn c225_l268_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c225_l268_action_invoke"); + let result = instance.call("f64.convert_s_i32", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 269 +fn c226_l269_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c226_l269_action_invoke"); + let result = instance.call("f64.convert_s_i32", &[Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 270 +fn c227_l270_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c227_l270_action_invoke"); + let result = instance.call("f64.convert_s_i32", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 271 +fn c228_l271_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c228_l271_action_invoke"); + let result = instance.call("f64.convert_s_i32", &[Value::I32(2147483647 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((2147483647.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 272 +fn c229_l272_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c229_l272_action_invoke"); + let result = instance.call("f64.convert_s_i32", &[Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((-2147483648.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 273 +fn c230_l273_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c230_l273_action_invoke"); + let result = instance.call("f64.convert_s_i32", &[Value::I32(987654321 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((987654321.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 275 +fn c231_l275_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c231_l275_action_invoke"); + let result = instance.call("f64.convert_s_i64", &[Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 276 +fn c232_l276_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c232_l276_action_invoke"); + let result = instance.call("f64.convert_s_i64", &[Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 277 +fn c233_l277_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c233_l277_action_invoke"); + let result = instance.call("f64.convert_s_i64", &[Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 278 +fn c234_l278_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c234_l278_action_invoke"); + let result = instance.call("f64.convert_s_i64", &[Value::I64(9223372036854775807 as i64)]); + assert_eq!(result, Ok(Some(Value::F64((9223372036854776000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 279 +fn c235_l279_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c235_l279_action_invoke"); + let result = instance.call("f64.convert_s_i64", &[Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::F64((-9223372036854776000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 280 +fn c236_l280_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c236_l280_action_invoke"); + let result = instance.call("f64.convert_s_i64", &[Value::I64(4669201609102990 as i64)]); + assert_eq!(result, Ok(Some(Value::F64((4669201609102990.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 282 +fn c237_l282_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c237_l282_action_invoke"); + let result = instance.call("f64.convert_s_i64", &[Value::I64(9007199254740993 as i64)]); + assert_eq!(result, Ok(Some(Value::F64((9007199254740992.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 283 +fn c238_l283_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c238_l283_action_invoke"); + let result = instance.call("f64.convert_s_i64", &[Value::I64(-9007199254740993 as i64)]); + assert_eq!(result, Ok(Some(Value::F64((-9007199254740992.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 284 +fn c239_l284_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c239_l284_action_invoke"); + let result = instance.call("f64.convert_s_i64", &[Value::I64(9007199254740995 as i64)]); + assert_eq!(result, Ok(Some(Value::F64((9007199254740996.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 285 +fn c240_l285_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c240_l285_action_invoke"); + let result = instance.call("f64.convert_s_i64", &[Value::I64(-9007199254740995 as i64)]); + assert_eq!(result, Ok(Some(Value::F64((-9007199254740996.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 287 +fn c241_l287_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c241_l287_action_invoke"); + let result = instance.call("f32.convert_u_i32", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 288 +fn c242_l288_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c242_l288_action_invoke"); + let result = instance.call("f32.convert_u_i32", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 289 +fn c243_l289_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c243_l289_action_invoke"); + let result = instance.call("f32.convert_u_i32", &[Value::I32(2147483647 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((2147483600.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 290 +fn c244_l290_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c244_l290_action_invoke"); + let result = instance.call("f32.convert_u_i32", &[Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((2147483600.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 291 +fn c245_l291_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c245_l291_action_invoke"); + let result = instance.call("f32.convert_u_i32", &[Value::I32(305419896 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((305419900.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 292 +fn c246_l292_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c246_l292_action_invoke"); + let result = instance.call("f32.convert_u_i32", &[Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((4294967300.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 293 +fn c247_l293_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c247_l293_action_invoke"); + let result = instance.call("f32.convert_u_i32", &[Value::I32(-2147483520 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((2147483600.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 294 +fn c248_l294_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c248_l294_action_invoke"); + let result = instance.call("f32.convert_u_i32", &[Value::I32(-2147483519 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((2147484000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 295 +fn c249_l295_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c249_l295_action_invoke"); + let result = instance.call("f32.convert_u_i32", &[Value::I32(-2147483518 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((2147484000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 296 +fn c250_l296_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c250_l296_action_invoke"); + let result = instance.call("f32.convert_u_i32", &[Value::I32(-384 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((4294966800.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 297 +fn c251_l297_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c251_l297_action_invoke"); + let result = instance.call("f32.convert_u_i32", &[Value::I32(-383 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((4294967000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 298 +fn c252_l298_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c252_l298_action_invoke"); + let result = instance.call("f32.convert_u_i32", &[Value::I32(-382 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((4294967000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 300 +fn c253_l300_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c253_l300_action_invoke"); + let result = instance.call("f32.convert_u_i32", &[Value::I32(16777217 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((16777216.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 301 +fn c254_l301_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c254_l301_action_invoke"); + let result = instance.call("f32.convert_u_i32", &[Value::I32(16777219 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((16777220.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 303 +fn c255_l303_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c255_l303_action_invoke"); + let result = instance.call("f32.convert_u_i64", &[Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 304 +fn c256_l304_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c256_l304_action_invoke"); + let result = instance.call("f32.convert_u_i64", &[Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 305 +fn c257_l305_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c257_l305_action_invoke"); + let result = instance.call("f32.convert_u_i64", &[Value::I64(9223372036854775807 as i64)]); + assert_eq!(result, Ok(Some(Value::F32((9223372000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 306 +fn c258_l306_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c258_l306_action_invoke"); + let result = instance.call("f32.convert_u_i64", &[Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::F32((9223372000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 307 +fn c259_l307_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c259_l307_action_invoke"); + let result = instance.call("f32.convert_u_i64", &[Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::F32((18446744000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 309 +fn c260_l309_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c260_l309_action_invoke"); + let result = instance.call("f32.convert_u_i64", &[Value::I64(16777217 as i64)]); + assert_eq!(result, Ok(Some(Value::F32((16777216.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 310 +fn c261_l310_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c261_l310_action_invoke"); + let result = instance.call("f32.convert_u_i64", &[Value::I64(16777219 as i64)]); + assert_eq!(result, Ok(Some(Value::F32((16777220.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 312 +fn c262_l312_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c262_l312_action_invoke"); + let result = instance.call("f64.convert_u_i32", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 313 +fn c263_l313_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c263_l313_action_invoke"); + let result = instance.call("f64.convert_u_i32", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 314 +fn c264_l314_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c264_l314_action_invoke"); + let result = instance.call("f64.convert_u_i32", &[Value::I32(2147483647 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((2147483647.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 315 +fn c265_l315_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c265_l315_action_invoke"); + let result = instance.call("f64.convert_u_i32", &[Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((2147483648.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 316 +fn c266_l316_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c266_l316_action_invoke"); + let result = instance.call("f64.convert_u_i32", &[Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((4294967295.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 318 +fn c267_l318_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c267_l318_action_invoke"); + let result = instance.call("f64.convert_u_i64", &[Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 319 +fn c268_l319_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c268_l319_action_invoke"); + let result = instance.call("f64.convert_u_i64", &[Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 320 +fn c269_l320_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c269_l320_action_invoke"); + let result = instance.call("f64.convert_u_i64", &[Value::I64(9223372036854775807 as i64)]); + assert_eq!(result, Ok(Some(Value::F64((9223372036854776000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 321 +fn c270_l321_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c270_l321_action_invoke"); + let result = instance.call("f64.convert_u_i64", &[Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::F64((9223372036854776000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 322 +fn c271_l322_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c271_l322_action_invoke"); + let result = instance.call("f64.convert_u_i64", &[Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::F64((18446744073709552000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 323 +fn c272_l323_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c272_l323_action_invoke"); + let result = instance.call("f64.convert_u_i64", &[Value::I64(-9223372036854774784 as i64)]); + assert_eq!(result, Ok(Some(Value::F64((9223372036854776000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 324 +fn c273_l324_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c273_l324_action_invoke"); + let result = instance.call("f64.convert_u_i64", &[Value::I64(-9223372036854774783 as i64)]); + assert_eq!(result, Ok(Some(Value::F64((9223372036854778000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 325 +fn c274_l325_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c274_l325_action_invoke"); + let result = instance.call("f64.convert_u_i64", &[Value::I64(-9223372036854774782 as i64)]); + assert_eq!(result, Ok(Some(Value::F64((9223372036854778000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 326 +fn c275_l326_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c275_l326_action_invoke"); + let result = instance.call("f64.convert_u_i64", &[Value::I64(-3072 as i64)]); + assert_eq!(result, Ok(Some(Value::F64((18446744073709548000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 327 +fn c276_l327_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c276_l327_action_invoke"); + let result = instance.call("f64.convert_u_i64", &[Value::I64(-3071 as i64)]); + assert_eq!(result, Ok(Some(Value::F64((18446744073709550000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 328 +fn c277_l328_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c277_l328_action_invoke"); + let result = instance.call("f64.convert_u_i64", &[Value::I64(-3070 as i64)]); + assert_eq!(result, Ok(Some(Value::F64((18446744073709550000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 330 +fn c278_l330_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c278_l330_action_invoke"); + let result = instance.call("f64.convert_u_i64", &[Value::I64(9007199254740993 as i64)]); + assert_eq!(result, Ok(Some(Value::F64((9007199254740992.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 331 +fn c279_l331_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c279_l331_action_invoke"); + let result = instance.call("f64.convert_u_i64", &[Value::I64(9007199254740995 as i64)]); + assert_eq!(result, Ok(Some(Value::F64((9007199254740996.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 333 +fn c280_l333_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c280_l333_action_invoke"); + let result = instance.call("f64.promote_f32", &[Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 334 +fn c281_l334_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c281_l334_action_invoke"); + let result = instance.call("f64.promote_f32", &[Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 335 +fn c282_l335_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c282_l335_action_invoke"); + let result = instance.call("f64.promote_f32", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000001401298464324817f64).to_bits())))); + result.map(|_| ()) +} + +// Line 336 +fn c283_l336_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c283_l336_action_invoke"); + let result = instance.call("f64.promote_f32", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000001401298464324817f64).to_bits())))); + result.map(|_| ()) +} + +// Line 337 +fn c284_l337_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c284_l337_action_invoke"); + let result = instance.call("f64.promote_f32", &[Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 338 +fn c285_l338_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c285_l338_action_invoke"); + let result = instance.call("f64.promote_f32", &[Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 339 +fn c286_l339_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c286_l339_action_invoke"); + let result = instance.call("f64.promote_f32", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-340282346638528860000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 340 +fn c287_l340_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c287_l340_action_invoke"); + let result = instance.call("f64.promote_f32", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((340282346638528860000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 342 +fn c288_l342_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c288_l342_action_invoke"); + let result = instance.call("f64.promote_f32", &[Value::F32((0.0000000000000000000000000000000000015046328f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000001504632769052528f64).to_bits())))); + result.map(|_| ()) +} + +// Line 344 +fn c289_l344_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c289_l344_action_invoke"); + let result = instance.call("f64.promote_f32", &[Value::F32((66382537000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((66382536710104395000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 345 +fn c290_l345_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c290_l345_action_invoke"); + let result = instance.call("f64.promote_f32", &[Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 346 +fn c291_l346_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c291_l346_action_invoke"); + let result = instance.call("f64.promote_f32", &[Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 347 +fn c292_l347_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c292_l347_assert_return_canonical_nan"); + let result = instance.call("f64.promote_f32", &[Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c292_l347_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 348 +fn c293_l348_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c293_l348_assert_return_arithmetic_nan"); + let result = instance.call("f64.promote_f32", &[Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c293_l348_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 349 +fn c294_l349_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c294_l349_assert_return_canonical_nan"); + let result = instance.call("f64.promote_f32", &[Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c294_l349_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 350 +fn c295_l350_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c295_l350_assert_return_arithmetic_nan"); + let result = instance.call("f64.promote_f32", &[Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c295_l350_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 352 +fn c296_l352_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c296_l352_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 353 +fn c297_l353_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c297_l353_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 354 +fn c298_l354_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c298_l354_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 355 +fn c299_l355_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c299_l355_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 356 +fn c300_l356_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c300_l356_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 357 +fn c301_l357_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c301_l357_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 358 +fn c302_l358_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c302_l358_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((0.000000000000000000000000000000000000011754942807573643f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 359 +fn c303_l359_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c303_l359_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((-0.000000000000000000000000000000000000011754942807573643f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 360 +fn c304_l360_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c304_l360_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((0.000000000000000000000000000000000000011754942807573642f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754942f32).to_bits())))); + result.map(|_| ()) +} + +// Line 361 +fn c305_l361_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c305_l361_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((-0.000000000000000000000000000000000000011754942807573642f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754942f32).to_bits())))); + result.map(|_| ()) +} + +// Line 362 +fn c306_l362_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c306_l362_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((0.000000000000000000000000000000000000000000001401298464324817f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 363 +fn c307_l363_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c307_l363_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((-0.000000000000000000000000000000000000000000001401298464324817f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 364 +fn c308_l364_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c308_l364_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((340282336497324060000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282330000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 365 +fn c309_l365_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c309_l365_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((-340282336497324060000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282330000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 366 +fn c310_l366_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c310_l366_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((340282336497324100000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 367 +fn c311_l367_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c311_l367_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((-340282336497324100000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 368 +fn c312_l368_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c312_l368_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((340282346638528860000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 369 +fn c313_l369_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c313_l369_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((-340282346638528860000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 370 +fn c314_l370_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c314_l370_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((340282356779733620000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 371 +fn c315_l371_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c315_l371_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((-340282356779733620000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 372 +fn c316_l372_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c316_l372_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((340282356779733660000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 373 +fn c317_l373_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c317_l373_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((-340282356779733660000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 374 +fn c318_l374_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c318_l374_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((0.000000000000000000000000000000000001504632769052528f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000000000000000000015046328f32).to_bits())))); + result.map(|_| ()) +} + +// Line 375 +fn c319_l375_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c319_l375_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((66382536710104395000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((66382537000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 376 +fn c320_l376_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c320_l376_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 377 +fn c321_l377_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c321_l377_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 378 +fn c322_l378_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c322_l378_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((1.0000000000000002f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 379 +fn c323_l379_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c323_l379_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((0.9999999999999999f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 380 +fn c324_l380_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c324_l380_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((1.0000000596046448f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 381 +fn c325_l381_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c325_l381_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((1.000000059604645f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 382 +fn c326_l382_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c326_l382_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((1.000000178813934f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 383 +fn c327_l383_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c327_l383_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((1.0000001788139343f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0000002f32).to_bits())))); + result.map(|_| ()) +} + +// Line 384 +fn c328_l384_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c328_l384_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((1.0000002980232239f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0000002f32).to_bits())))); + result.map(|_| ()) +} + +// Line 385 +fn c329_l385_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c329_l385_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((16777217.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((16777216.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 386 +fn c330_l386_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c330_l386_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((16777217.000000004f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((16777218.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 387 +fn c331_l387_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c331_l387_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((16777218.999999996f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((16777218.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 388 +fn c332_l388_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c332_l388_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((16777219.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((16777220.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 389 +fn c333_l389_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c333_l389_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((424258443299142700000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((424258450000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 390 +fn c334_l390_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c334_l390_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((0.0000000000000000000000000000000001569262107843488f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000000000000000000015692621f32).to_bits())))); + result.map(|_| ()) +} + +// Line 391 +fn c335_l391_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c335_l391_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((0.000000000000000000000000000000000000010551773688605172f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000010551773f32).to_bits())))); + result.map(|_| ()) +} + +// Line 392 +fn c336_l392_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c336_l392_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((-2.8238128484141933f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-2.823813f32).to_bits())))); + result.map(|_| ()) +} + +// Line 393 +fn c337_l393_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c337_l393_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((-9063376370095757000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-9063376000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 394 +fn c338_l394_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c338_l394_assert_return_canonical_nan"); + let result = instance.call("f32.demote_f64", &[Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c338_l394_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 395 +fn c339_l395_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c339_l395_assert_return_arithmetic_nan"); + let result = instance.call("f32.demote_f64", &[Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c339_l395_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 396 +fn c340_l396_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c340_l396_assert_return_canonical_nan"); + let result = instance.call("f32.demote_f64", &[Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c340_l396_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 397 +fn c341_l397_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c341_l397_assert_return_arithmetic_nan"); + let result = instance.call("f32.demote_f64", &[Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c341_l397_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 398 +fn c342_l398_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c342_l398_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 399 +fn c343_l399_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c343_l399_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 400 +fn c344_l400_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c344_l400_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((0.0000000000000000000000000000000000000000000007006492321624085f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 401 +fn c345_l401_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c345_l401_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((-0.0000000000000000000000000000000000000000000007006492321624085f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 402 +fn c346_l402_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c346_l402_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((0.0000000000000000000000000000000000000000000007006492321624087f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 403 +fn c347_l403_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c347_l403_action_invoke"); + let result = instance.call("f32.demote_f64", &[Value::F64((-0.0000000000000000000000000000000000000000000007006492321624087f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 405 +fn c348_l405_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c348_l405_action_invoke"); + let result = instance.call("f32.reinterpret_i32", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 406 +fn c349_l406_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c349_l406_action_invoke"); + let result = instance.call("f32.reinterpret_i32", &[Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 407 +fn c350_l407_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c350_l407_action_invoke"); + let result = instance.call("f32.reinterpret_i32", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 408 +fn c351_l408_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c351_l408_action_invoke"); + let result = instance.call("f32.reinterpret_i32", &[Value::I32(-1 as i32)]); + let expected = f32::from_bits(4294967295); + 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 409 +fn c352_l409_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c352_l409_action_invoke"); + let result = instance.call("f32.reinterpret_i32", &[Value::I32(123456789 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000000000000000000016535997f32).to_bits())))); + result.map(|_| ()) +} + +// Line 410 +fn c353_l410_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c353_l410_action_invoke"); + let result = instance.call("f32.reinterpret_i32", &[Value::I32(-2147483647 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 411 +fn c354_l411_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c354_l411_action_invoke"); + let result = instance.call("f32.reinterpret_i32", &[Value::I32(2139095040 as i32)]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 412 +fn c355_l412_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c355_l412_action_invoke"); + let result = instance.call("f32.reinterpret_i32", &[Value::I32(-8388608 as i32)]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 413 +fn c356_l413_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c356_l413_action_invoke"); + let result = instance.call("f32.reinterpret_i32", &[Value::I32(2143289344 as i32)]); + 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 414 +fn c357_l414_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c357_l414_action_invoke"); + let result = instance.call("f32.reinterpret_i32", &[Value::I32(-4194304 as i32)]); + 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 415 +fn c358_l415_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c358_l415_action_invoke"); + let result = instance.call("f32.reinterpret_i32", &[Value::I32(2141192192 as i32)]); + let expected = f32::from_bits(2141192192); + 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 416 +fn c359_l416_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c359_l416_action_invoke"); + let result = instance.call("f32.reinterpret_i32", &[Value::I32(-6291456 as i32)]); + let expected = f32::from_bits(4288675840); + 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 418 +fn c360_l418_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c360_l418_action_invoke"); + let result = instance.call("f64.reinterpret_i64", &[Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 419 +fn c361_l419_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c361_l419_action_invoke"); + let result = instance.call("f64.reinterpret_i64", &[Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 420 +fn c362_l420_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c362_l420_action_invoke"); + let result = instance.call("f64.reinterpret_i64", &[Value::I64(-1 as i64)]); + let expected = f64::from_bits(18446744073709551615); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 421 +fn c363_l421_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c363_l421_action_invoke"); + let result = instance.call("f64.reinterpret_i64", &[Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 422 +fn c364_l422_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c364_l422_action_invoke"); + let result = instance.call("f64.reinterpret_i64", &[Value::I64(1234567890 as i64)]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000609957582f64).to_bits())))); + result.map(|_| ()) +} + +// Line 423 +fn c365_l423_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c365_l423_action_invoke"); + let result = instance.call("f64.reinterpret_i64", &[Value::I64(-9223372036854775807 as i64)]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 424 +fn c366_l424_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c366_l424_action_invoke"); + let result = instance.call("f64.reinterpret_i64", &[Value::I64(9218868437227405312 as i64)]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 425 +fn c367_l425_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c367_l425_action_invoke"); + let result = instance.call("f64.reinterpret_i64", &[Value::I64(-4503599627370496 as i64)]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 426 +fn c368_l426_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c368_l426_action_invoke"); + let result = instance.call("f64.reinterpret_i64", &[Value::I64(9221120237041090560 as i64)]); + let expected = f64::from_bits(9221120237041090560); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 427 +fn c369_l427_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c369_l427_action_invoke"); + let result = instance.call("f64.reinterpret_i64", &[Value::I64(-2251799813685248 as i64)]); + let expected = f64::from_bits(18444492273895866368); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 428 +fn c370_l428_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c370_l428_action_invoke"); + let result = instance.call("f64.reinterpret_i64", &[Value::I64(9219994337134247936 as i64)]); + let expected = f64::from_bits(9219994337134247936); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 429 +fn c371_l429_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c371_l429_action_invoke"); + let result = instance.call("f64.reinterpret_i64", &[Value::I64(-3377699720527872 as i64)]); + let expected = f64::from_bits(18443366373989023744); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 431 +fn c372_l431_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c372_l431_action_invoke"); + let result = instance.call("i32.reinterpret_f32", &[Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 432 +fn c373_l432_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c373_l432_action_invoke"); + let result = instance.call("i32.reinterpret_f32", &[Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(-2147483648 as i32)))); + result.map(|_| ()) +} + +// Line 433 +fn c374_l433_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c374_l433_action_invoke"); + let result = instance.call("i32.reinterpret_f32", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 434 +fn c375_l434_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c375_l434_action_invoke"); + let result = instance.call("i32.reinterpret_f32", &[Value::F32(f32::from_bits(4294967295) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 435 +fn c376_l435_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c376_l435_action_invoke"); + let result = instance.call("i32.reinterpret_f32", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(-2147483647 as i32)))); + result.map(|_| ()) +} + +// Line 436 +fn c377_l436_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c377_l436_action_invoke"); + let result = instance.call("i32.reinterpret_f32", &[Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1065353216 as i32)))); + result.map(|_| ()) +} + +// Line 437 +fn c378_l437_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c378_l437_action_invoke"); + let result = instance.call("i32.reinterpret_f32", &[Value::F32((3.1415925f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1078530010 as i32)))); + result.map(|_| ()) +} + +// Line 438 +fn c379_l438_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c379_l438_action_invoke"); + let result = instance.call("i32.reinterpret_f32", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(2139095039 as i32)))); + result.map(|_| ()) +} + +// Line 439 +fn c380_l439_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c380_l439_action_invoke"); + let result = instance.call("i32.reinterpret_f32", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(-8388609 as i32)))); + result.map(|_| ()) +} + +// Line 440 +fn c381_l440_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c381_l440_action_invoke"); + let result = instance.call("i32.reinterpret_f32", &[Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(2139095040 as i32)))); + result.map(|_| ()) +} + +// Line 441 +fn c382_l441_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c382_l441_action_invoke"); + let result = instance.call("i32.reinterpret_f32", &[Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(-8388608 as i32)))); + result.map(|_| ()) +} + +// Line 442 +fn c383_l442_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c383_l442_action_invoke"); + let result = instance.call("i32.reinterpret_f32", &[Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(2143289344 as i32)))); + result.map(|_| ()) +} + +// Line 443 +fn c384_l443_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c384_l443_action_invoke"); + let result = instance.call("i32.reinterpret_f32", &[Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(-4194304 as i32)))); + result.map(|_| ()) +} + +// Line 444 +fn c385_l444_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c385_l444_action_invoke"); + let result = instance.call("i32.reinterpret_f32", &[Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(2141192192 as i32)))); + result.map(|_| ()) +} + +// Line 445 +fn c386_l445_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c386_l445_action_invoke"); + let result = instance.call("i32.reinterpret_f32", &[Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(-6291456 as i32)))); + result.map(|_| ()) +} + +// Line 447 +fn c387_l447_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c387_l447_action_invoke"); + let result = instance.call("i64.reinterpret_f64", &[Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 448 +fn c388_l448_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c388_l448_action_invoke"); + let result = instance.call("i64.reinterpret_f64", &[Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(-9223372036854775808 as i64)))); + result.map(|_| ()) +} + +// Line 449 +fn c389_l449_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c389_l449_action_invoke"); + let result = instance.call("i64.reinterpret_f64", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 450 +fn c390_l450_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c390_l450_action_invoke"); + let result = instance.call("i64.reinterpret_f64", &[Value::F64(f64::from_bits(18446744073709551615) as u64)]); + assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); + result.map(|_| ()) +} + +// Line 451 +fn c391_l451_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c391_l451_action_invoke"); + let result = instance.call("i64.reinterpret_f64", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(-9223372036854775807 as i64)))); + result.map(|_| ()) +} + +// Line 452 +fn c392_l452_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c392_l452_action_invoke"); + let result = instance.call("i64.reinterpret_f64", &[Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(4607182418800017408 as i64)))); + result.map(|_| ()) +} + +// Line 453 +fn c393_l453_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c393_l453_action_invoke"); + let result = instance.call("i64.reinterpret_f64", &[Value::F64((3.14159265358979f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(4614256656552045841 as i64)))); + result.map(|_| ()) +} + +// Line 454 +fn c394_l454_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c394_l454_action_invoke"); + let result = instance.call("i64.reinterpret_f64", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(9218868437227405311 as i64)))); + result.map(|_| ()) +} + +// Line 455 +fn c395_l455_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c395_l455_action_invoke"); + let result = instance.call("i64.reinterpret_f64", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(-4503599627370497 as i64)))); + result.map(|_| ()) +} + +// Line 456 +fn c396_l456_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c396_l456_action_invoke"); + let result = instance.call("i64.reinterpret_f64", &[Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(9218868437227405312 as i64)))); + result.map(|_| ()) +} + +// Line 457 +fn c397_l457_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c397_l457_action_invoke"); + let result = instance.call("i64.reinterpret_f64", &[Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I64(-4503599627370496 as i64)))); + result.map(|_| ()) +} + +// Line 458 +fn c398_l458_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c398_l458_action_invoke"); + let result = instance.call("i64.reinterpret_f64", &[Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I64(9221120237041090560 as i64)))); + result.map(|_| ()) +} + +// Line 459 +fn c399_l459_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c399_l459_action_invoke"); + let result = instance.call("i64.reinterpret_f64", &[Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I64(-2251799813685248 as i64)))); + result.map(|_| ()) +} + +// Line 460 +fn c400_l460_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c400_l460_action_invoke"); + let result = instance.call("i64.reinterpret_f64", &[Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I64(9219994337134247936 as i64)))); + result.map(|_| ()) +} + +// Line 461 +fn c401_l461_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c401_l461_action_invoke"); + let result = instance.call("i64.reinterpret_f64", &[Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I64(-3377699720527872 as i64)))); + result.map(|_| ()) +} + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l29_action_invoke(&mut instance); + c2_l30_action_invoke(&mut instance); + c3_l31_action_invoke(&mut instance); + c4_l32_action_invoke(&mut instance); + c5_l33_action_invoke(&mut instance); + c6_l34_action_invoke(&mut instance); + c7_l36_action_invoke(&mut instance); + c8_l37_action_invoke(&mut instance); + c9_l38_action_invoke(&mut instance); + c10_l39_action_invoke(&mut instance); + c11_l40_action_invoke(&mut instance); + c12_l41_action_invoke(&mut instance); + c13_l43_action_invoke(&mut instance); + c14_l44_action_invoke(&mut instance); + c15_l45_action_invoke(&mut instance); + c16_l46_action_invoke(&mut instance); + c17_l47_action_invoke(&mut instance); + c18_l48_action_invoke(&mut instance); + c19_l49_action_invoke(&mut instance); + c20_l50_action_invoke(&mut instance); + c21_l51_action_invoke(&mut instance); + c22_l52_action_invoke(&mut instance); + c23_l53_action_invoke(&mut instance); + c24_l54_action_invoke(&mut instance); + c25_l56_action_invoke(&mut instance); + c26_l57_action_invoke(&mut instance); + c27_l58_action_invoke(&mut instance); + c28_l59_action_invoke(&mut instance); + c29_l60_action_invoke(&mut instance); + c30_l61_action_invoke(&mut instance); + c31_l62_action_invoke(&mut instance); + c32_l63_action_invoke(&mut instance); + c33_l64_action_invoke(&mut instance); + c34_l65_action_invoke(&mut instance); + c35_l66_action_invoke(&mut instance); + c36_l67_action_invoke(&mut instance); + c37_l68_action_invoke(&mut instance); + c38_l69_action_invoke(&mut instance); + c47_l79_action_invoke(&mut instance); + c48_l80_action_invoke(&mut instance); + c49_l81_action_invoke(&mut instance); + c50_l82_action_invoke(&mut instance); + c51_l83_action_invoke(&mut instance); + c52_l84_action_invoke(&mut instance); + c53_l85_action_invoke(&mut instance); + c54_l86_action_invoke(&mut instance); + c55_l87_action_invoke(&mut instance); + c56_l88_action_invoke(&mut instance); + c57_l89_action_invoke(&mut instance); + c58_l90_action_invoke(&mut instance); + c59_l91_action_invoke(&mut instance); + c68_l101_action_invoke(&mut instance); + c69_l102_action_invoke(&mut instance); + c70_l103_action_invoke(&mut instance); + c71_l104_action_invoke(&mut instance); + c72_l105_action_invoke(&mut instance); + c73_l106_action_invoke(&mut instance); + c74_l107_action_invoke(&mut instance); + c75_l108_action_invoke(&mut instance); + c76_l109_action_invoke(&mut instance); + c77_l110_action_invoke(&mut instance); + c78_l111_action_invoke(&mut instance); + c79_l112_action_invoke(&mut instance); + c80_l113_action_invoke(&mut instance); + c81_l114_action_invoke(&mut instance); + c90_l124_action_invoke(&mut instance); + c91_l125_action_invoke(&mut instance); + c92_l126_action_invoke(&mut instance); + c93_l127_action_invoke(&mut instance); + c94_l128_action_invoke(&mut instance); + c95_l129_action_invoke(&mut instance); + c96_l130_action_invoke(&mut instance); + c97_l131_action_invoke(&mut instance); + c98_l132_action_invoke(&mut instance); + c99_l133_action_invoke(&mut instance); + c100_l134_action_invoke(&mut instance); + c101_l135_action_invoke(&mut instance); + c102_l136_action_invoke(&mut instance); + c103_l137_action_invoke(&mut instance); + c115_l150_action_invoke(&mut instance); + c116_l151_action_invoke(&mut instance); + c117_l152_action_invoke(&mut instance); + c118_l153_action_invoke(&mut instance); + c119_l154_action_invoke(&mut instance); + c120_l155_action_invoke(&mut instance); + c121_l156_action_invoke(&mut instance); + c122_l157_action_invoke(&mut instance); + c123_l158_action_invoke(&mut instance); + c124_l159_action_invoke(&mut instance); + c125_l160_action_invoke(&mut instance); + c126_l161_action_invoke(&mut instance); + c127_l162_action_invoke(&mut instance); + c128_l163_action_invoke(&mut instance); + c129_l164_action_invoke(&mut instance); + c130_l165_action_invoke(&mut instance); + c139_l175_action_invoke(&mut instance); + c140_l176_action_invoke(&mut instance); + c141_l177_action_invoke(&mut instance); + c142_l178_action_invoke(&mut instance); + c143_l179_action_invoke(&mut instance); + c144_l180_action_invoke(&mut instance); + c145_l181_action_invoke(&mut instance); + c146_l182_action_invoke(&mut instance); + c147_l183_action_invoke(&mut instance); + c148_l184_action_invoke(&mut instance); + c149_l185_action_invoke(&mut instance); + c158_l195_action_invoke(&mut instance); + c159_l196_action_invoke(&mut instance); + c160_l197_action_invoke(&mut instance); + c161_l198_action_invoke(&mut instance); + c162_l199_action_invoke(&mut instance); + c163_l200_action_invoke(&mut instance); + c164_l201_action_invoke(&mut instance); + c165_l202_action_invoke(&mut instance); + c166_l203_action_invoke(&mut instance); + c167_l204_action_invoke(&mut instance); + c168_l205_action_invoke(&mut instance); + c169_l206_action_invoke(&mut instance); + c170_l207_action_invoke(&mut instance); + c171_l208_action_invoke(&mut instance); + c172_l209_action_invoke(&mut instance); + c173_l210_action_invoke(&mut instance); + c182_l220_action_invoke(&mut instance); + c183_l221_action_invoke(&mut instance); + c184_l222_action_invoke(&mut instance); + c185_l223_action_invoke(&mut instance); + c186_l224_action_invoke(&mut instance); + c187_l225_action_invoke(&mut instance); + c188_l226_action_invoke(&mut instance); + c189_l227_action_invoke(&mut instance); + c190_l228_action_invoke(&mut instance); + c191_l229_action_invoke(&mut instance); + c192_l230_action_invoke(&mut instance); + c193_l231_action_invoke(&mut instance); + c194_l232_action_invoke(&mut instance); + c195_l233_action_invoke(&mut instance); + c196_l234_action_invoke(&mut instance); + c205_l244_action_invoke(&mut instance); + c206_l245_action_invoke(&mut instance); + c207_l246_action_invoke(&mut instance); + c208_l247_action_invoke(&mut instance); + c209_l248_action_invoke(&mut instance); + c210_l249_action_invoke(&mut instance); + c211_l251_action_invoke(&mut instance); + c212_l252_action_invoke(&mut instance); + c213_l253_action_invoke(&mut instance); + c214_l254_action_invoke(&mut instance); + c215_l256_action_invoke(&mut instance); + c216_l257_action_invoke(&mut instance); + c217_l258_action_invoke(&mut instance); + c218_l259_action_invoke(&mut instance); + c219_l260_action_invoke(&mut instance); + c220_l261_action_invoke(&mut instance); + c221_l263_action_invoke(&mut instance); + c222_l264_action_invoke(&mut instance); + c223_l265_action_invoke(&mut instance); + c224_l266_action_invoke(&mut instance); + c225_l268_action_invoke(&mut instance); + c226_l269_action_invoke(&mut instance); + c227_l270_action_invoke(&mut instance); + c228_l271_action_invoke(&mut instance); + c229_l272_action_invoke(&mut instance); + c230_l273_action_invoke(&mut instance); + c231_l275_action_invoke(&mut instance); + c232_l276_action_invoke(&mut instance); + c233_l277_action_invoke(&mut instance); + c234_l278_action_invoke(&mut instance); + c235_l279_action_invoke(&mut instance); + c236_l280_action_invoke(&mut instance); + c237_l282_action_invoke(&mut instance); + c238_l283_action_invoke(&mut instance); + c239_l284_action_invoke(&mut instance); + c240_l285_action_invoke(&mut instance); + c241_l287_action_invoke(&mut instance); + c242_l288_action_invoke(&mut instance); + c243_l289_action_invoke(&mut instance); + c244_l290_action_invoke(&mut instance); + c245_l291_action_invoke(&mut instance); + c246_l292_action_invoke(&mut instance); + c247_l293_action_invoke(&mut instance); + c248_l294_action_invoke(&mut instance); + c249_l295_action_invoke(&mut instance); + c250_l296_action_invoke(&mut instance); + c251_l297_action_invoke(&mut instance); + c252_l298_action_invoke(&mut instance); + c253_l300_action_invoke(&mut instance); + c254_l301_action_invoke(&mut instance); + c255_l303_action_invoke(&mut instance); + c256_l304_action_invoke(&mut instance); + c257_l305_action_invoke(&mut instance); + c258_l306_action_invoke(&mut instance); + c259_l307_action_invoke(&mut instance); + c260_l309_action_invoke(&mut instance); + c261_l310_action_invoke(&mut instance); + c262_l312_action_invoke(&mut instance); + c263_l313_action_invoke(&mut instance); + c264_l314_action_invoke(&mut instance); + c265_l315_action_invoke(&mut instance); + c266_l316_action_invoke(&mut instance); + c267_l318_action_invoke(&mut instance); + c268_l319_action_invoke(&mut instance); + c269_l320_action_invoke(&mut instance); + c270_l321_action_invoke(&mut instance); + c271_l322_action_invoke(&mut instance); + c272_l323_action_invoke(&mut instance); + c273_l324_action_invoke(&mut instance); + c274_l325_action_invoke(&mut instance); + c275_l326_action_invoke(&mut instance); + c276_l327_action_invoke(&mut instance); + c277_l328_action_invoke(&mut instance); + c278_l330_action_invoke(&mut instance); + c279_l331_action_invoke(&mut instance); + c280_l333_action_invoke(&mut instance); + c281_l334_action_invoke(&mut instance); + c282_l335_action_invoke(&mut instance); + c283_l336_action_invoke(&mut instance); + c284_l337_action_invoke(&mut instance); + c285_l338_action_invoke(&mut instance); + c286_l339_action_invoke(&mut instance); + c287_l340_action_invoke(&mut instance); + c288_l342_action_invoke(&mut instance); + c289_l344_action_invoke(&mut instance); + c290_l345_action_invoke(&mut instance); + c291_l346_action_invoke(&mut instance); + c292_l347_assert_return_canonical_nan(&mut instance); + c293_l348_assert_return_arithmetic_nan(&mut instance); + c294_l349_assert_return_canonical_nan(&mut instance); + c295_l350_assert_return_arithmetic_nan(&mut instance); + c296_l352_action_invoke(&mut instance); + c297_l353_action_invoke(&mut instance); + c298_l354_action_invoke(&mut instance); + c299_l355_action_invoke(&mut instance); + c300_l356_action_invoke(&mut instance); + c301_l357_action_invoke(&mut instance); + c302_l358_action_invoke(&mut instance); + c303_l359_action_invoke(&mut instance); + c304_l360_action_invoke(&mut instance); + c305_l361_action_invoke(&mut instance); + c306_l362_action_invoke(&mut instance); + c307_l363_action_invoke(&mut instance); + c308_l364_action_invoke(&mut instance); + c309_l365_action_invoke(&mut instance); + c310_l366_action_invoke(&mut instance); + c311_l367_action_invoke(&mut instance); + c312_l368_action_invoke(&mut instance); + c313_l369_action_invoke(&mut instance); + c314_l370_action_invoke(&mut instance); + c315_l371_action_invoke(&mut instance); + c316_l372_action_invoke(&mut instance); + c317_l373_action_invoke(&mut instance); + c318_l374_action_invoke(&mut instance); + c319_l375_action_invoke(&mut instance); + c320_l376_action_invoke(&mut instance); + c321_l377_action_invoke(&mut instance); + c322_l378_action_invoke(&mut instance); + c323_l379_action_invoke(&mut instance); + c324_l380_action_invoke(&mut instance); + c325_l381_action_invoke(&mut instance); + c326_l382_action_invoke(&mut instance); + c327_l383_action_invoke(&mut instance); + c328_l384_action_invoke(&mut instance); + c329_l385_action_invoke(&mut instance); + c330_l386_action_invoke(&mut instance); + c331_l387_action_invoke(&mut instance); + c332_l388_action_invoke(&mut instance); + c333_l389_action_invoke(&mut instance); + c334_l390_action_invoke(&mut instance); + c335_l391_action_invoke(&mut instance); + c336_l392_action_invoke(&mut instance); + c337_l393_action_invoke(&mut instance); + c338_l394_assert_return_canonical_nan(&mut instance); + c339_l395_assert_return_arithmetic_nan(&mut instance); + c340_l396_assert_return_canonical_nan(&mut instance); + c341_l397_assert_return_arithmetic_nan(&mut instance); + c342_l398_action_invoke(&mut instance); + c343_l399_action_invoke(&mut instance); + c344_l400_action_invoke(&mut instance); + c345_l401_action_invoke(&mut instance); + c346_l402_action_invoke(&mut instance); + c347_l403_action_invoke(&mut instance); + c348_l405_action_invoke(&mut instance); + c349_l406_action_invoke(&mut instance); + c350_l407_action_invoke(&mut instance); + c351_l408_action_invoke(&mut instance); + c352_l409_action_invoke(&mut instance); + c353_l410_action_invoke(&mut instance); + c354_l411_action_invoke(&mut instance); + c355_l412_action_invoke(&mut instance); + c356_l413_action_invoke(&mut instance); + c357_l414_action_invoke(&mut instance); + c358_l415_action_invoke(&mut instance); + c359_l416_action_invoke(&mut instance); + c360_l418_action_invoke(&mut instance); + c361_l419_action_invoke(&mut instance); + c362_l420_action_invoke(&mut instance); + c363_l421_action_invoke(&mut instance); + c364_l422_action_invoke(&mut instance); + c365_l423_action_invoke(&mut instance); + c366_l424_action_invoke(&mut instance); + c367_l425_action_invoke(&mut instance); + c368_l426_action_invoke(&mut instance); + c369_l427_action_invoke(&mut instance); + c370_l428_action_invoke(&mut instance); + c371_l429_action_invoke(&mut instance); + c372_l431_action_invoke(&mut instance); + c373_l432_action_invoke(&mut instance); + c374_l433_action_invoke(&mut instance); + c375_l434_action_invoke(&mut instance); + c376_l435_action_invoke(&mut instance); + c377_l436_action_invoke(&mut instance); + c378_l437_action_invoke(&mut instance); + c379_l438_action_invoke(&mut instance); + c380_l439_action_invoke(&mut instance); + c381_l440_action_invoke(&mut instance); + c382_l441_action_invoke(&mut instance); + c383_l442_action_invoke(&mut instance); + c384_l443_action_invoke(&mut instance); + c385_l444_action_invoke(&mut instance); + c386_l445_action_invoke(&mut instance); + c387_l447_action_invoke(&mut instance); + c388_l448_action_invoke(&mut instance); + c389_l449_action_invoke(&mut instance); + c390_l450_action_invoke(&mut instance); + c391_l451_action_invoke(&mut instance); + c392_l452_action_invoke(&mut instance); + c393_l453_action_invoke(&mut instance); + c394_l454_action_invoke(&mut instance); + c395_l455_action_invoke(&mut instance); + c396_l456_action_invoke(&mut instance); + c397_l457_action_invoke(&mut instance); + c398_l458_action_invoke(&mut instance); + c399_l459_action_invoke(&mut instance); + c400_l460_action_invoke(&mut instance); + c401_l461_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/custom.rs b/lib/runtime/tests/spectests/custom.rs new file mode 100644 index 000000000..a5281f48b --- /dev/null +++ b/lib/runtime/tests/spectests/custom.rs @@ -0,0 +1,144 @@ +// 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/custom.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 1 +fn create_module_1() -> Box { + let module_str = "(module) + "; + 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 14 + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); +} +fn create_module_2() -> Box { + let module_str = "(module) + "; + 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_2(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 50 + +#[test] +fn test_module_2() { + let mut instance = create_module_2(); + // We group the calls together + start_module_2(&mut instance); +} +fn create_module_3() -> Box { + let module_str = "(module + (type (;0;) (func (param i32 i32) (result i32))) + (func (;0;) (type 0) (param i32 i32) (result i32) + get_local 0 + get_local 1 + i32.add) + (export \"addTwo\" (func 0))) + "; + 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_3(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 61 +#[test] +fn c3_l61_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 0]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 69 +#[test] +fn c4_l69_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 0, 0]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 77 +#[test] +fn c5_l77_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 0, 0, 0, 5, 1, 0, 7, 0, 0]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 85 +#[test] +fn c6_l85_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 0, 38, 16, 97, 32, 99, 117, 115, 116, 111, 109, 32, 115, 101, 99, 116, 105, 111, 110, 116, 104, 105, 115, 32, 105, 115, 32, 116, 104, 101, 32, 112, 97, 121, 108, 111, 97, 100]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 93 +#[test] +fn c7_l93_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 0, 37, 16, 97, 32, 99, 117, 115, 116, 111, 109, 32, 115, 101, 99, 116, 105, 111, 110, 116, 104, 105, 115, 32, 105, 115, 32, 116, 104, 101, 32, 112, 97, 121, 108, 111, 97, 100, 0, 36, 16, 97, 32, 99, 117, 115, 116, 111, 109, 32, 115, 101, 99, 116, 105, 111, 110, 116, 104, 105, 115, 32, 105, 115, 32, 116, 104, 101, 32, 112, 97, 121, 108, 111, 97, 100]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 102 +#[test] +fn c8_l102_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 7, 1, 96, 2, 127, 127, 1, 127, 0, 37, 16, 97, 32, 99, 117, 115, 116, 111, 109, 32, 115, 101, 99, 116, 105, 111, 110, 116, 104, 105, 115, 32, 105, 115, 32, 116, 104, 101, 32, 112, 97, 121, 108, 111, 97, 100, 3, 2, 1, 0, 10, 9, 1, 7, 0, 32, 0, 32, 1, 106, 11, 0, 27, 7, 99, 117, 115, 116, 111, 109, 50, 116, 104, 105, 115, 32, 105, 115, 32, 116, 104, 101, 32, 112, 97, 121, 108, 111, 97, 100]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 115 +#[test] +fn c9_l115_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 0, 97, 115, 109, 1, 0, 0, 0]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +#[test] +fn test_module_3() { + let mut instance = create_module_3(); + // We group the calls together + start_module_3(&mut instance); +} diff --git a/lib/runtime/tests/spectests/data.rs b/lib/runtime/tests/spectests/data.rs new file mode 100644 index 000000000..131ea05c8 --- /dev/null +++ b/lib/runtime/tests/spectests/data.rs @@ -0,0 +1,554 @@ +// 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/data.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 5 +fn create_module_1() -> Box { + let module_str = "(module + (memory (;0;) 1) + (data (;0;) (i32.const 0) \"\") + (data (;1;) (i32.const 1) \"abcd\") + (data (;2;) (i32.const 0) \"\") + (data (;3;) (i32.const 0) \"abc\") + (data (;4;) (i32.const 0) \"\") + (data (;5;) (i32.const 1) \"abcd\") + (data (;6;) (i32.const 0) \"\") + (data (;7;) (i32.const 0) \"abc\") + (data (;8;) (i32.const 0) \"\") + (data (;9;) (i32.const 1) \"abcd\") + (data (;10;) (i32.const 0) \"\") + (data (;11;) (i32.const 0) \"abc\")) + "; + 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 23 + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); +} +fn create_module_2() -> Box { + let module_str = "(module + (memory (;0;) 1) + (data (;0;) (i32.const 0) \"a\")) + "; + 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_2(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 27 + +#[test] +fn test_module_2() { + let mut instance = create_module_2(); + // We group the calls together + start_module_2(&mut instance); +} +fn create_module_3() -> Box { + let module_str = "(module + (import \"spectest\" \"memory\" (memory (;0;) 1)) + (data (;0;) (i32.const 0) \"a\")) + "; + 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_3(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 32 + +#[test] +fn test_module_3() { + let mut instance = create_module_3(); + // We group the calls together + start_module_3(&mut instance); +} +fn create_module_4() -> Box { + let module_str = "(module + (memory (;0;) 1) + (data (;0;) (i32.const 0) \"a\") + (data (;1;) (i32.const 3) \"b\") + (data (;2;) (i32.const 100) \"cde\") + (data (;3;) (i32.const 5) \"x\") + (data (;4;) (i32.const 3) \"c\")) + "; + 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_4(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 40 + +#[test] +fn test_module_4() { + let mut instance = create_module_4(); + // We group the calls together + start_module_4(&mut instance); +} +fn create_module_5() -> Box { + let module_str = "(module + (import \"spectest\" \"memory\" (memory (;0;) 1)) + (data (;0;) (i32.const 0) \"a\") + (data (;1;) (i32.const 1) \"b\") + (data (;2;) (i32.const 2) \"cde\") + (data (;3;) (i32.const 3) \"f\") + (data (;4;) (i32.const 2) \"g\") + (data (;5;) (i32.const 1) \"h\")) + "; + 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_5(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 82 + +#[test] +fn test_module_5() { + let mut instance = create_module_5(); + // We group the calls together + start_module_5(&mut instance); +} +fn create_module_6() -> Box { + let module_str = "(module + (memory (;0;) 1) + (data (;0;) (i32.const 0) \"a\") + (data (;1;) (i32.const 65535) \"b\")) + "; + 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_6(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 87 + +#[test] +fn test_module_6() { + let mut instance = create_module_6(); + // We group the calls together + start_module_6(&mut instance); +} +fn create_module_7() -> Box { + let module_str = "(module + (import \"spectest\" \"memory\" (memory (;0;) 1)) + (data (;0;) (i32.const 0) \"a\") + (data (;1;) (i32.const 65535) \"b\")) + "; + 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_7(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 93 + +#[test] +fn test_module_7() { + let mut instance = create_module_7(); + // We group the calls together + start_module_7(&mut instance); +} +fn create_module_8() -> Box { + let module_str = "(module + (memory (;0;) 2) + (data (;0;) (i32.const 131071) \"a\")) + "; + 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_8(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 98 + +#[test] +fn test_module_8() { + let mut instance = create_module_8(); + // We group the calls together + start_module_8(&mut instance); +} +fn create_module_9() -> Box { + let module_str = "(module + (memory (;0;) 0) + (data (;0;) (i32.const 0) \"\")) + "; + 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_9(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 102 + +#[test] +fn test_module_9() { + let mut instance = create_module_9(); + // We group the calls together + start_module_9(&mut instance); +} +fn create_module_10() -> Box { + let module_str = "(module + (import \"spectest\" \"memory\" (memory (;0;) 0)) + (data (;0;) (i32.const 0) \"\")) + "; + 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_10(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 107 + +#[test] +fn test_module_10() { + let mut instance = create_module_10(); + // We group the calls together + start_module_10(&mut instance); +} +fn create_module_11() -> Box { + let module_str = "(module + (memory (;0;) 0 0) + (data (;0;) (i32.const 0) \"\")) + "; + 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_11(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 112 + +#[test] +fn test_module_11() { + let mut instance = create_module_11(); + // We group the calls together + start_module_11(&mut instance); +} +fn create_module_12() -> Box { + let module_str = "(module + (memory (;0;) 1) + (data (;0;) (i32.const 65536) \"\")) + "; + 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_12(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 117 + +#[test] +fn test_module_12() { + let mut instance = create_module_12(); + // We group the calls together + start_module_12(&mut instance); +} +fn create_module_13() -> Box { + let module_str = "(module + (memory (;0;) 0) + (data (;0;) (i32.const 0) \"\")) + "; + 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_13(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 121 + +#[test] +fn test_module_13() { + let mut instance = create_module_13(); + // We group the calls together + start_module_13(&mut instance); +} +fn create_module_14() -> Box { + let module_str = "(module + (import \"spectest\" \"memory\" (memory (;0;) 0)) + (data (;0;) (i32.const 0) \"\")) + "; + 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_14(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 126 + +#[test] +fn test_module_14() { + let mut instance = create_module_14(); + // We group the calls together + start_module_14(&mut instance); +} +fn create_module_15() -> Box { + let module_str = "(module + (memory (;0;) 0 0) + (data (;0;) (i32.const 0) \"\")) + "; + 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_15(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 131 + +#[test] +fn test_module_15() { + let mut instance = create_module_15(); + // We group the calls together + start_module_15(&mut instance); +} +fn create_module_16() -> Box { + let module_str = "(module + (import \"spectest\" \"memory\" (memory (;0;) 0)) + (data (;0;) (i32.const 0) \"a\")) + "; + 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_16(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 136 + +#[test] +fn test_module_16() { + let mut instance = create_module_16(); + // We group the calls together + start_module_16(&mut instance); +} +fn create_module_17() -> Box { + let module_str = "(module + (import \"spectest\" \"memory\" (memory (;0;) 0 3)) + (data (;0;) (i32.const 0) \"a\")) + "; + 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_17(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 155 + +#[test] +fn test_module_17() { + let mut instance = create_module_17(); + // We group the calls together + start_module_17(&mut instance); +} +fn create_module_18() -> Box { + let module_str = "(module + (import \"spectest\" \"memory\" (memory (;0;) 0)) + (data (;0;) (i32.const 1) \"a\")) + "; + 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_18(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 160 + +#[test] +fn test_module_18() { + let mut instance = create_module_18(); + // We group the calls together + start_module_18(&mut instance); +} +fn create_module_19() -> Box { + let module_str = "(module + (import \"spectest\" \"memory\" (memory (;0;) 0 3)) + (data (;0;) (i32.const 1) \"a\")) + "; + 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_19(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 168 + +// Line 176 + +// Line 184 + +// Line 192 + +// Line 200 + +// Line 217 + +// Line 226 + +// Line 233 + +// Line 241 + +// Line 249 + +// Line 257 + +// Line 264 + +// Line 272 + +// Line 279 + +// Line 289 +#[test] +fn c33_l289_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 11, 6, 1, 0, 65, 0, 11, 0]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 298 +#[test] +fn c34_l298_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 3, 1, 0, 1, 11, 6, 1, 0, 66, 0, 11, 0]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 306 +#[test] +fn c35_l306_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 3, 1, 0, 1, 11, 7, 1, 0, 65, 0, 104, 11, 0]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 314 +#[test] +fn c36_l314_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 3, 1, 0, 1, 11, 5, 1, 0, 1, 11, 0]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 322 +#[test] +fn c37_l322_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 3, 1, 0, 1, 11, 7, 1, 0, 1, 65, 0, 11, 0]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 330 +#[test] +fn c38_l330_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 3, 1, 0, 1, 11, 7, 1, 0, 65, 0, 1, 11, 0]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +#[test] +fn test_module_19() { + let mut instance = create_module_19(); + // We group the calls together + start_module_19(&mut instance); +} diff --git a/lib/runtime/tests/spectests/elem.rs b/lib/runtime/tests/spectests/elem.rs new file mode 100644 index 000000000..f222d4d89 --- /dev/null +++ b/lib/runtime/tests/spectests/elem.rs @@ -0,0 +1,745 @@ +// 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/elem.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 4 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0)) + (table (;0;) 10 anyfunc) + (elem (;0;) (i32.const 0)) + (elem (;1;) (i32.const 0) 0 0) + (elem (;2;) (i32.const 0)) + (elem (;3;) (i32.const 0) 0 0) + (elem (;4;) (i32.const 0)) + (elem (;5;) (i32.const 0) 0 0) + (elem (;6;) (i32.const 0)) + (elem (;7;) (i32.const 0) 0 0) + (elem (;8;) (i32.const 0)) + (elem (;9;) (i32.const 0) 0 0) + (elem (;10;) (i32.const 0)) + (elem (;11;) (i32.const 0) 0 0)) + "; + 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 23 + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); +} +fn create_module_2() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0)) + (table (;0;) 10 anyfunc) + (elem (;0;) (i32.const 0) 0)) + "; + 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_2(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 28 + +#[test] +fn test_module_2() { + let mut instance = create_module_2(); + // We group the calls together + start_module_2(&mut instance); +} +fn create_module_3() -> Box { + let module_str = "(module + (type (;0;) (func)) + (import \"spectest\" \"table\" (table (;0;) 10 anyfunc)) + (func (;0;) (type 0)) + (elem (;0;) (i32.const 0) 0)) + "; + 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_3(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 34 + +#[test] +fn test_module_3() { + let mut instance = create_module_3(); + // We group the calls together + start_module_3(&mut instance); +} +fn create_module_4() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0)) + (table (;0;) 10 anyfunc) + (elem (;0;) (i32.const 0) 0) + (elem (;1;) (i32.const 3) 0) + (elem (;2;) (i32.const 7) 0) + (elem (;3;) (i32.const 5) 0) + (elem (;4;) (i32.const 3) 0)) + "; + 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_4(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 43 + +#[test] +fn test_module_4() { + let mut instance = create_module_4(); + // We group the calls together + start_module_4(&mut instance); +} +fn create_module_5() -> Box { + let module_str = "(module + (type (;0;) (func)) + (import \"spectest\" \"table\" (table (;0;) 10 anyfunc)) + (func (;0;) (type 0)) + (elem (;0;) (i32.const 9) 0) + (elem (;1;) (i32.const 3) 0) + (elem (;2;) (i32.const 7) 0) + (elem (;3;) (i32.const 3) 0) + (elem (;4;) (i32.const 5) 0)) + "; + 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_5(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 53 + +#[test] +fn test_module_5() { + let mut instance = create_module_5(); + // We group the calls together + start_module_5(&mut instance); +} +fn create_module_6() -> Box { + let module_str = "(module + (type (;0;) (func)) + (import \"spectest\" \"global_i32\" (global (;0;) i32)) + (func (;0;) (type 0)) + (table (;0;) 1000 anyfunc) + (elem (;0;) (i32.const 0) 0)) + "; + 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_6(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 60 + +#[test] +fn test_module_6() { + let mut instance = create_module_6(); + // We group the calls together + start_module_6(&mut instance); +} +fn create_module_7() -> Box { + let module_str = "(module + (type (;0;) (func)) + (import \"spectest\" \"global_i32\" (global (;0;) i32)) + (func (;0;) (type 0)) + (table (;0;) 1000 anyfunc) + (elem (;0;) (get_global 0) 0)) + "; + 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_7(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 67 + +#[test] +fn test_module_7() { + let mut instance = create_module_7(); + // We group the calls together + start_module_7(&mut instance); +} +fn create_module_8() -> Box { + let module_str = "(module + (type (;0;) (func (result i32))) + (func (;0;) (type 0) (result i32) + i32.const 65) + (func (;1;) (type 0) (result i32) + i32.const 66) + (func (;2;) (type 0) (result i32) + i32.const 7 + call_indirect (type 0)) + (func (;3;) (type 0) (result i32) + i32.const 9 + call_indirect (type 0)) + (table (;0;) 10 anyfunc) + (export \"call-7\" (func 2)) + (export \"call-9\" (func 3)) + (elem (;0;) (i32.const 7) 0) + (elem (;1;) (i32.const 9) 1)) + "; + 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_8(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 81 +fn c8_l81_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l81_action_invoke"); + let result = instance.call("call-7", &[]); + assert_eq!(result, Ok(Some(Value::I32(65 as i32)))); + result.map(|_| ()) +} + +// Line 82 +fn c9_l82_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l82_action_invoke"); + let result = instance.call("call-9", &[]); + assert_eq!(result, Ok(Some(Value::I32(66 as i32)))); + result.map(|_| ()) +} + +// Line 86 + +#[test] +fn test_module_8() { + let mut instance = create_module_8(); + // We group the calls together + start_module_8(&mut instance); + c8_l81_action_invoke(&mut instance); + c9_l82_action_invoke(&mut instance); +} +fn create_module_9() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0)) + (table (;0;) 10 anyfunc) + (elem (;0;) (i32.const 9) 0)) + "; + 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_9(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 91 + +#[test] +fn test_module_9() { + let mut instance = create_module_9(); + // We group the calls together + start_module_9(&mut instance); +} +fn create_module_10() -> Box { + let module_str = "(module + (type (;0;) (func)) + (import \"spectest\" \"table\" (table (;0;) 10 anyfunc)) + (func (;0;) (type 0)) + (elem (;0;) (i32.const 9) 0)) + "; + 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_10(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 97 + +#[test] +fn test_module_10() { + let mut instance = create_module_10(); + // We group the calls together + start_module_10(&mut instance); +} +fn create_module_11() -> Box { + let module_str = "(module + (table (;0;) 0 anyfunc) + (elem (;0;) (i32.const 0))) + "; + 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_11(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 101 + +#[test] +fn test_module_11() { + let mut instance = create_module_11(); + // We group the calls together + start_module_11(&mut instance); +} +fn create_module_12() -> Box { + let module_str = "(module + (import \"spectest\" \"table\" (table (;0;) 0 anyfunc)) + (elem (;0;) (i32.const 0))) + "; + 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_12(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 106 + +#[test] +fn test_module_12() { + let mut instance = create_module_12(); + // We group the calls together + start_module_12(&mut instance); +} +fn create_module_13() -> Box { + let module_str = "(module + (table (;0;) 0 0 anyfunc) + (elem (;0;) (i32.const 0))) + "; + 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_13(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 111 + +#[test] +fn test_module_13() { + let mut instance = create_module_13(); + // We group the calls together + start_module_13(&mut instance); +} +fn create_module_14() -> Box { + let module_str = "(module + (table (;0;) 20 anyfunc) + (elem (;0;) (i32.const 20))) + "; + 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_14(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 116 + +#[test] +fn test_module_14() { + let mut instance = create_module_14(); + // We group the calls together + start_module_14(&mut instance); +} +fn create_module_15() -> Box { + let module_str = "(module + (type (;0;) (func)) + (import \"spectest\" \"table\" (table (;0;) 0 anyfunc)) + (func (;0;) (type 0)) + (elem (;0;) (i32.const 0) 0)) + "; + 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_15(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 122 + +#[test] +fn test_module_15() { + let mut instance = create_module_15(); + // We group the calls together + start_module_15(&mut instance); +} +fn create_module_16() -> Box { + let module_str = "(module + (type (;0;) (func)) + (import \"spectest\" \"table\" (table (;0;) 0 100 anyfunc)) + (func (;0;) (type 0)) + (elem (;0;) (i32.const 0) 0)) + "; + 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_16(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 128 + +#[test] +fn test_module_16() { + let mut instance = create_module_16(); + // We group the calls together + start_module_16(&mut instance); +} +fn create_module_17() -> Box { + let module_str = "(module + (type (;0;) (func)) + (import \"spectest\" \"table\" (table (;0;) 0 anyfunc)) + (func (;0;) (type 0)) + (elem (;0;) (i32.const 1) 0)) + "; + 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_17(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 134 + +#[test] +fn test_module_17() { + let mut instance = create_module_17(); + // We group the calls together + start_module_17(&mut instance); +} +fn create_module_18() -> Box { + let module_str = "(module + (type (;0;) (func)) + (import \"spectest\" \"table\" (table (;0;) 0 30 anyfunc)) + (func (;0;) (type 0)) + (elem (;0;) (i32.const 1) 0)) + "; + 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_18(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 143 + +// Line 152 + +// Line 161 + +// Line 170 + +// Line 178 + +// Line 186 + +// Line 195 + +// Line 203 + +// Line 212 + +// Line 220 + +// Line 229 + +// Line 237 + +// Line 248 +#[test] +fn c32_l248_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 9, 7, 1, 0, 65, 0, 11, 1, 0, 10, 4, 1, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 258 +#[test] +fn c33_l258_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 1, 9, 6, 1, 0, 66, 0, 11, 0]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 266 +#[test] +fn c34_l266_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 1, 9, 7, 1, 0, 65, 0, 104, 11, 0]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 274 +#[test] +fn c35_l274_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 1, 9, 5, 1, 0, 1, 11, 0]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 282 +#[test] +fn c36_l282_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 1, 9, 7, 1, 0, 1, 65, 0, 11, 0]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 290 +#[test] +fn c37_l290_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 1, 9, 7, 1, 0, 65, 0, 1, 11, 0]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 305 + +#[test] +fn test_module_18() { + let mut instance = create_module_18(); + // We group the calls together + start_module_18(&mut instance); +} +fn create_module_19() -> Box { + let module_str = "(module + (type (;0;) (func (result i32))) + (func (;0;) (type 0) (result i32) + i32.const 65) + (func (;1;) (type 0) (result i32) + i32.const 66) + (func (;2;) (type 0) (result i32) + i32.const 9 + call_indirect (type 0)) + (table (;0;) 10 anyfunc) + (export \"call-overwritten\" (func 2)) + (elem (;0;) (i32.const 9) 0) + (elem (;1;) (i32.const 9) 1)) + "; + 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_19(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 316 +fn c39_l316_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c39_l316_action_invoke"); + let result = instance.call("call-overwritten", &[]); + assert_eq!(result, Ok(Some(Value::I32(66 as i32)))); + result.map(|_| ()) +} + +// Line 318 + +#[test] +fn test_module_19() { + let mut instance = create_module_19(); + // We group the calls together + start_module_19(&mut instance); + c39_l316_action_invoke(&mut instance); +} +fn create_module_20() -> Box { + let module_str = "(module + (type (;0;) (func (result i32))) + (import \"spectest\" \"table\" (table (;0;) 10 anyfunc)) + (func (;0;) (type 0) (result i32) + i32.const 65) + (func (;1;) (type 0) (result i32) + i32.const 66) + (func (;2;) (type 0) (result i32) + i32.const 9 + call_indirect (type 0)) + (export \"call-overwritten-element\" (func 2)) + (elem (;0;) (i32.const 9) 0) + (elem (;1;) (i32.const 9) 1)) + "; + 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_20(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 329 +fn c41_l329_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c41_l329_action_invoke"); + let result = instance.call("call-overwritten-element", &[]); + assert_eq!(result, Ok(Some(Value::I32(66 as i32)))); + result.map(|_| ()) +} + +// Line 333 + +#[test] +fn test_module_20() { + let mut instance = create_module_20(); + // We group the calls together + start_module_20(&mut instance); + c41_l329_action_invoke(&mut instance); +} +fn create_module_21() -> Box { + let module_str = "(module + (type (;0;) (func (result i32))) + (func (;0;) (type 0) (result i32) + i32.const 65) + (func (;1;) (type 0) (result i32) + i32.const 66) + (func (;2;) (type 0) (result i32) + i32.const 7 + call_indirect (type 0)) + (func (;3;) (type 0) (result i32) + i32.const 8 + call_indirect (type 0)) + (func (;4;) (type 0) (result i32) + i32.const 9 + call_indirect (type 0)) + (table (;0;) 10 anyfunc) + (export \"shared-table\" (table 0)) + (export \"call-7\" (func 2)) + (export \"call-8\" (func 3)) + (export \"call-9\" (func 4)) + (elem (;0;) (i32.const 8) 0) + (elem (;1;) (i32.const 9) 1)) + "; + 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_21(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 351 + +// Line 353 +fn c44_l353_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c44_l353_action_invoke"); + let result = instance.call("call-7", &[]); + + result.map(|_| ()) +} + +#[test] +fn c44_l353_assert_trap() { + let mut instance = create_module_21(); + let result = c44_l353_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 354 +fn c45_l354_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c45_l354_action_invoke"); + let result = instance.call("call-8", &[]); + assert_eq!(result, Ok(Some(Value::I32(65 as i32)))); + result.map(|_| ()) +} + +// Line 355 +fn c46_l355_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c46_l355_action_invoke"); + let result = instance.call("call-9", &[]); + assert_eq!(result, Ok(Some(Value::I32(66 as i32)))); + result.map(|_| ()) +} + +#[test] +fn test_module_21() { + let mut instance = create_module_21(); + // We group the calls together + start_module_21(&mut instance); + c45_l354_action_invoke(&mut instance); + c46_l355_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/endianness.rs b/lib/runtime/tests/spectests/endianness.rs new file mode 100644 index 000000000..517c1fec8 --- /dev/null +++ b/lib/runtime/tests/spectests/endianness.rs @@ -0,0 +1,856 @@ +// 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/endianness.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 1 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func (param i32 i32))) + (type (;1;) (func (param i32 i64))) + (type (;2;) (func (param i32) (result i32))) + (type (;3;) (func (param i32) (result i64))) + (type (;4;) (func (param i64) (result i64))) + (type (;5;) (func (param f32) (result f32))) + (type (;6;) (func (param f64) (result f64))) + (func (;0;) (type 0) (param i32 i32) + get_local 0 + get_local 1 + i32.store8 + get_local 0 + i32.const 1 + i32.add + get_local 1 + i32.const 8 + i32.shr_u + i32.store8) + (func (;1;) (type 0) (param i32 i32) + get_local 0 + get_local 1 + call 0 + get_local 0 + i32.const 2 + i32.add + get_local 1 + i32.const 16 + i32.shr_u + call 0) + (func (;2;) (type 1) (param i32 i64) + get_local 0 + get_local 1 + i32.wrap/i64 + call 1 + get_local 0 + i32.const 4 + i32.add + get_local 1 + i64.const 32 + i64.shr_u + i32.wrap/i64 + call 1) + (func (;3;) (type 2) (param i32) (result i32) + get_local 0 + i32.load8_u + get_local 0 + i32.const 1 + i32.add + i32.load8_u + i32.const 8 + i32.shl + i32.or) + (func (;4;) (type 2) (param i32) (result i32) + get_local 0 + call 3 + get_local 0 + i32.const 2 + i32.add + call 3 + i32.const 16 + i32.shl + i32.or) + (func (;5;) (type 3) (param i32) (result i64) + get_local 0 + call 4 + i64.extend_u/i32 + get_local 0 + i32.const 4 + i32.add + call 4 + i64.extend_u/i32 + i64.const 32 + i64.shl + i64.or) + (func (;6;) (type 2) (param i32) (result i32) + i32.const 0 + get_local 0 + call 0 + i32.const 0 + i32.load16_s) + (func (;7;) (type 2) (param i32) (result i32) + i32.const 0 + get_local 0 + call 0 + i32.const 0 + i32.load16_u) + (func (;8;) (type 2) (param i32) (result i32) + i32.const 0 + get_local 0 + call 1 + i32.const 0 + i32.load) + (func (;9;) (type 4) (param i64) (result i64) + i32.const 0 + get_local 0 + i32.wrap/i64 + call 0 + i32.const 0 + i64.load16_s) + (func (;10;) (type 4) (param i64) (result i64) + i32.const 0 + get_local 0 + i32.wrap/i64 + call 0 + i32.const 0 + i64.load16_u) + (func (;11;) (type 4) (param i64) (result i64) + i32.const 0 + get_local 0 + i32.wrap/i64 + call 1 + i32.const 0 + i64.load32_s) + (func (;12;) (type 4) (param i64) (result i64) + i32.const 0 + get_local 0 + i32.wrap/i64 + call 1 + i32.const 0 + i64.load32_u) + (func (;13;) (type 4) (param i64) (result i64) + i32.const 0 + get_local 0 + call 2 + i32.const 0 + i64.load) + (func (;14;) (type 5) (param f32) (result f32) + i32.const 0 + get_local 0 + i32.reinterpret/f32 + call 1 + i32.const 0 + f32.load) + (func (;15;) (type 6) (param f64) (result f64) + i32.const 0 + get_local 0 + i64.reinterpret/f64 + call 2 + i32.const 0 + f64.load) + (func (;16;) (type 2) (param i32) (result i32) + i32.const 0 + get_local 0 + i32.store16 + i32.const 0 + call 3) + (func (;17;) (type 2) (param i32) (result i32) + i32.const 0 + get_local 0 + i32.store + i32.const 0 + call 4) + (func (;18;) (type 4) (param i64) (result i64) + i32.const 0 + get_local 0 + i64.store16 + i32.const 0 + call 3 + i64.extend_u/i32) + (func (;19;) (type 4) (param i64) (result i64) + i32.const 0 + get_local 0 + i64.store32 + i32.const 0 + call 4 + i64.extend_u/i32) + (func (;20;) (type 4) (param i64) (result i64) + i32.const 0 + get_local 0 + i64.store + i32.const 0 + call 5) + (func (;21;) (type 5) (param f32) (result f32) + i32.const 0 + get_local 0 + f32.store + i32.const 0 + call 4 + f32.reinterpret/i32) + (func (;22;) (type 6) (param f64) (result f64) + i32.const 0 + get_local 0 + f64.store + i32.const 0 + call 5 + f64.reinterpret/i64) + (memory (;0;) 1) + (export \"i32_load16_s\" (func 6)) + (export \"i32_load16_u\" (func 7)) + (export \"i32_load\" (func 8)) + (export \"i64_load16_s\" (func 9)) + (export \"i64_load16_u\" (func 10)) + (export \"i64_load32_s\" (func 11)) + (export \"i64_load32_u\" (func 12)) + (export \"i64_load\" (func 13)) + (export \"f32_load\" (func 14)) + (export \"f64_load\" (func 15)) + (export \"i32_store16\" (func 16)) + (export \"i32_store\" (func 17)) + (export \"i64_store16\" (func 18)) + (export \"i64_store32\" (func 19)) + (export \"i64_store\" (func 20)) + (export \"f32_store\" (func 21)) + (export \"f64_store\" (func 22))) + "; + 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 133 +fn c1_l133_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l133_action_invoke"); + let result = instance.call("i32_load16_s", &[Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 134 +fn c2_l134_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l134_action_invoke"); + let result = instance.call("i32_load16_s", &[Value::I32(-4242 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-4242 as i32)))); + result.map(|_| ()) +} + +// Line 135 +fn c3_l135_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l135_action_invoke"); + let result = instance.call("i32_load16_s", &[Value::I32(42 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(42 as i32)))); + result.map(|_| ()) +} + +// Line 136 +fn c4_l136_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l136_action_invoke"); + let result = instance.call("i32_load16_s", &[Value::I32(12816 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(12816 as i32)))); + result.map(|_| ()) +} + +// Line 138 +fn c5_l138_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l138_action_invoke"); + let result = instance.call("i32_load16_u", &[Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(65535 as i32)))); + result.map(|_| ()) +} + +// Line 139 +fn c6_l139_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l139_action_invoke"); + let result = instance.call("i32_load16_u", &[Value::I32(-4242 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(61294 as i32)))); + result.map(|_| ()) +} + +// Line 140 +fn c7_l140_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l140_action_invoke"); + let result = instance.call("i32_load16_u", &[Value::I32(42 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(42 as i32)))); + result.map(|_| ()) +} + +// Line 141 +fn c8_l141_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l141_action_invoke"); + let result = instance.call("i32_load16_u", &[Value::I32(51966 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(51966 as i32)))); + result.map(|_| ()) +} + +// Line 143 +fn c9_l143_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l143_action_invoke"); + let result = instance.call("i32_load", &[Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 144 +fn c10_l144_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c10_l144_action_invoke"); + let result = instance.call("i32_load", &[Value::I32(-42424242 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-42424242 as i32)))); + result.map(|_| ()) +} + +// Line 145 +fn c11_l145_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c11_l145_action_invoke"); + let result = instance.call("i32_load", &[Value::I32(42424242 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(42424242 as i32)))); + result.map(|_| ()) +} + +// Line 146 +fn c12_l146_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c12_l146_action_invoke"); + let result = instance.call("i32_load", &[Value::I32(-1414717974 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-1414717974 as i32)))); + result.map(|_| ()) +} + +// Line 148 +fn c13_l148_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c13_l148_action_invoke"); + let result = instance.call("i64_load16_s", &[Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); + result.map(|_| ()) +} + +// Line 149 +fn c14_l149_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c14_l149_action_invoke"); + let result = instance.call("i64_load16_s", &[Value::I64(-4242 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-4242 as i64)))); + result.map(|_| ()) +} + +// Line 150 +fn c15_l150_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c15_l150_action_invoke"); + let result = instance.call("i64_load16_s", &[Value::I64(42 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(42 as i64)))); + result.map(|_| ()) +} + +// Line 151 +fn c16_l151_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c16_l151_action_invoke"); + let result = instance.call("i64_load16_s", &[Value::I64(12816 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(12816 as i64)))); + result.map(|_| ()) +} + +// Line 153 +fn c17_l153_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c17_l153_action_invoke"); + let result = instance.call("i64_load16_u", &[Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(65535 as i64)))); + result.map(|_| ()) +} + +// Line 154 +fn c18_l154_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c18_l154_action_invoke"); + let result = instance.call("i64_load16_u", &[Value::I64(-4242 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(61294 as i64)))); + result.map(|_| ()) +} + +// Line 155 +fn c19_l155_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c19_l155_action_invoke"); + let result = instance.call("i64_load16_u", &[Value::I64(42 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(42 as i64)))); + result.map(|_| ()) +} + +// Line 156 +fn c20_l156_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c20_l156_action_invoke"); + let result = instance.call("i64_load16_u", &[Value::I64(51966 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(51966 as i64)))); + result.map(|_| ()) +} + +// Line 158 +fn c21_l158_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c21_l158_action_invoke"); + let result = instance.call("i64_load32_s", &[Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); + result.map(|_| ()) +} + +// Line 159 +fn c22_l159_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c22_l159_action_invoke"); + let result = instance.call("i64_load32_s", &[Value::I64(-42424242 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-42424242 as i64)))); + result.map(|_| ()) +} + +// Line 160 +fn c23_l160_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c23_l160_action_invoke"); + let result = instance.call("i64_load32_s", &[Value::I64(42424242 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(42424242 as i64)))); + result.map(|_| ()) +} + +// Line 161 +fn c24_l161_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c24_l161_action_invoke"); + let result = instance.call("i64_load32_s", &[Value::I64(305419896 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(305419896 as i64)))); + result.map(|_| ()) +} + +// Line 163 +fn c25_l163_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c25_l163_action_invoke"); + let result = instance.call("i64_load32_u", &[Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(4294967295 as i64)))); + result.map(|_| ()) +} + +// Line 164 +fn c26_l164_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c26_l164_action_invoke"); + let result = instance.call("i64_load32_u", &[Value::I64(-42424242 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(4252543054 as i64)))); + result.map(|_| ()) +} + +// Line 165 +fn c27_l165_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c27_l165_action_invoke"); + let result = instance.call("i64_load32_u", &[Value::I64(42424242 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(42424242 as i64)))); + result.map(|_| ()) +} + +// Line 166 +fn c28_l166_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c28_l166_action_invoke"); + let result = instance.call("i64_load32_u", &[Value::I64(2880249322 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(2880249322 as i64)))); + result.map(|_| ()) +} + +// Line 168 +fn c29_l168_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c29_l168_action_invoke"); + let result = instance.call("i64_load", &[Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); + result.map(|_| ()) +} + +// Line 169 +fn c30_l169_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c30_l169_action_invoke"); + let result = instance.call("i64_load", &[Value::I64(-42424242 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-42424242 as i64)))); + result.map(|_| ()) +} + +// Line 170 +fn c31_l170_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c31_l170_action_invoke"); + let result = instance.call("i64_load", &[Value::I64(2880249322 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(2880249322 as i64)))); + result.map(|_| ()) +} + +// Line 171 +fn c32_l171_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c32_l171_action_invoke"); + let result = instance.call("i64_load", &[Value::I64(-6075977126246539798 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-6075977126246539798 as i64)))); + result.map(|_| ()) +} + +// Line 173 +fn c33_l173_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c33_l173_action_invoke"); + let result = instance.call("f32_load", &[Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 174 +fn c34_l174_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c34_l174_action_invoke"); + let result = instance.call("f32_load", &[Value::F32((0.01234f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.01234f32).to_bits())))); + result.map(|_| ()) +} + +// Line 175 +fn c35_l175_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c35_l175_action_invoke"); + let result = instance.call("f32_load", &[Value::F32((4242.4243f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((4242.4243f32).to_bits())))); + result.map(|_| ()) +} + +// Line 176 +fn c36_l176_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c36_l176_action_invoke"); + let result = instance.call("f32_load", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 178 +fn c37_l178_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c37_l178_action_invoke"); + let result = instance.call("f64_load", &[Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 179 +fn c38_l179_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c38_l179_action_invoke"); + let result = instance.call("f64_load", &[Value::F64((1234.56789f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1234.56789f64).to_bits())))); + result.map(|_| ()) +} + +// Line 180 +fn c39_l180_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c39_l180_action_invoke"); + let result = instance.call("f64_load", &[Value::F64((424242.424242f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((424242.424242f64).to_bits())))); + result.map(|_| ()) +} + +// Line 181 +fn c40_l181_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c40_l181_action_invoke"); + let result = instance.call("f64_load", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 184 +fn c41_l184_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c41_l184_action_invoke"); + let result = instance.call("i32_store16", &[Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(65535 as i32)))); + result.map(|_| ()) +} + +// Line 185 +fn c42_l185_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c42_l185_action_invoke"); + let result = instance.call("i32_store16", &[Value::I32(-4242 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(61294 as i32)))); + result.map(|_| ()) +} + +// Line 186 +fn c43_l186_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c43_l186_action_invoke"); + let result = instance.call("i32_store16", &[Value::I32(42 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(42 as i32)))); + result.map(|_| ()) +} + +// Line 187 +fn c44_l187_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c44_l187_action_invoke"); + let result = instance.call("i32_store16", &[Value::I32(51966 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(51966 as i32)))); + result.map(|_| ()) +} + +// Line 189 +fn c45_l189_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c45_l189_action_invoke"); + let result = instance.call("i32_store", &[Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 190 +fn c46_l190_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c46_l190_action_invoke"); + let result = instance.call("i32_store", &[Value::I32(-4242 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-4242 as i32)))); + result.map(|_| ()) +} + +// Line 191 +fn c47_l191_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c47_l191_action_invoke"); + let result = instance.call("i32_store", &[Value::I32(42424242 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(42424242 as i32)))); + result.map(|_| ()) +} + +// Line 192 +fn c48_l192_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c48_l192_action_invoke"); + let result = instance.call("i32_store", &[Value::I32(-559035650 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-559035650 as i32)))); + result.map(|_| ()) +} + +// Line 194 +fn c49_l194_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c49_l194_action_invoke"); + let result = instance.call("i64_store16", &[Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(65535 as i64)))); + result.map(|_| ()) +} + +// Line 195 +fn c50_l195_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c50_l195_action_invoke"); + let result = instance.call("i64_store16", &[Value::I64(-4242 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(61294 as i64)))); + result.map(|_| ()) +} + +// Line 196 +fn c51_l196_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c51_l196_action_invoke"); + let result = instance.call("i64_store16", &[Value::I64(42 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(42 as i64)))); + result.map(|_| ()) +} + +// Line 197 +fn c52_l197_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c52_l197_action_invoke"); + let result = instance.call("i64_store16", &[Value::I64(51966 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(51966 as i64)))); + result.map(|_| ()) +} + +// Line 199 +fn c53_l199_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c53_l199_action_invoke"); + let result = instance.call("i64_store32", &[Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(4294967295 as i64)))); + result.map(|_| ()) +} + +// Line 200 +fn c54_l200_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c54_l200_action_invoke"); + let result = instance.call("i64_store32", &[Value::I64(-4242 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(4294963054 as i64)))); + result.map(|_| ()) +} + +// Line 201 +fn c55_l201_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c55_l201_action_invoke"); + let result = instance.call("i64_store32", &[Value::I64(42424242 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(42424242 as i64)))); + result.map(|_| ()) +} + +// Line 202 +fn c56_l202_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c56_l202_action_invoke"); + let result = instance.call("i64_store32", &[Value::I64(3735931646 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(3735931646 as i64)))); + result.map(|_| ()) +} + +// Line 204 +fn c57_l204_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c57_l204_action_invoke"); + let result = instance.call("i64_store", &[Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); + result.map(|_| ()) +} + +// Line 205 +fn c58_l205_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c58_l205_action_invoke"); + let result = instance.call("i64_store", &[Value::I64(-42424242 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-42424242 as i64)))); + result.map(|_| ()) +} + +// Line 206 +fn c59_l206_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c59_l206_action_invoke"); + let result = instance.call("i64_store", &[Value::I64(2880249322 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(2880249322 as i64)))); + result.map(|_| ()) +} + +// Line 207 +fn c60_l207_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c60_l207_action_invoke"); + let result = instance.call("i64_store", &[Value::I64(-6075977126246539798 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-6075977126246539798 as i64)))); + result.map(|_| ()) +} + +// Line 209 +fn c61_l209_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c61_l209_action_invoke"); + let result = instance.call("f32_store", &[Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 210 +fn c62_l210_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c62_l210_action_invoke"); + let result = instance.call("f32_store", &[Value::F32((0.01234f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.01234f32).to_bits())))); + result.map(|_| ()) +} + +// Line 211 +fn c63_l211_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c63_l211_action_invoke"); + let result = instance.call("f32_store", &[Value::F32((4242.4243f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((4242.4243f32).to_bits())))); + result.map(|_| ()) +} + +// Line 212 +fn c64_l212_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c64_l212_action_invoke"); + let result = instance.call("f32_store", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 214 +fn c65_l214_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c65_l214_action_invoke"); + let result = instance.call("f64_store", &[Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 215 +fn c66_l215_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c66_l215_action_invoke"); + let result = instance.call("f64_store", &[Value::F64((1234.56789f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1234.56789f64).to_bits())))); + result.map(|_| ()) +} + +// Line 216 +fn c67_l216_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c67_l216_action_invoke"); + let result = instance.call("f64_store", &[Value::F64((424242.424242f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((424242.424242f64).to_bits())))); + result.map(|_| ()) +} + +// Line 217 +fn c68_l217_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c68_l217_action_invoke"); + let result = instance.call("f64_store", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l133_action_invoke(&mut instance); + c2_l134_action_invoke(&mut instance); + c3_l135_action_invoke(&mut instance); + c4_l136_action_invoke(&mut instance); + c5_l138_action_invoke(&mut instance); + c6_l139_action_invoke(&mut instance); + c7_l140_action_invoke(&mut instance); + c8_l141_action_invoke(&mut instance); + c9_l143_action_invoke(&mut instance); + c10_l144_action_invoke(&mut instance); + c11_l145_action_invoke(&mut instance); + c12_l146_action_invoke(&mut instance); + c13_l148_action_invoke(&mut instance); + c14_l149_action_invoke(&mut instance); + c15_l150_action_invoke(&mut instance); + c16_l151_action_invoke(&mut instance); + c17_l153_action_invoke(&mut instance); + c18_l154_action_invoke(&mut instance); + c19_l155_action_invoke(&mut instance); + c20_l156_action_invoke(&mut instance); + c21_l158_action_invoke(&mut instance); + c22_l159_action_invoke(&mut instance); + c23_l160_action_invoke(&mut instance); + c24_l161_action_invoke(&mut instance); + c25_l163_action_invoke(&mut instance); + c26_l164_action_invoke(&mut instance); + c27_l165_action_invoke(&mut instance); + c28_l166_action_invoke(&mut instance); + c29_l168_action_invoke(&mut instance); + c30_l169_action_invoke(&mut instance); + c31_l170_action_invoke(&mut instance); + c32_l171_action_invoke(&mut instance); + c33_l173_action_invoke(&mut instance); + c34_l174_action_invoke(&mut instance); + c35_l175_action_invoke(&mut instance); + c36_l176_action_invoke(&mut instance); + c37_l178_action_invoke(&mut instance); + c38_l179_action_invoke(&mut instance); + c39_l180_action_invoke(&mut instance); + c40_l181_action_invoke(&mut instance); + c41_l184_action_invoke(&mut instance); + c42_l185_action_invoke(&mut instance); + c43_l186_action_invoke(&mut instance); + c44_l187_action_invoke(&mut instance); + c45_l189_action_invoke(&mut instance); + c46_l190_action_invoke(&mut instance); + c47_l191_action_invoke(&mut instance); + c48_l192_action_invoke(&mut instance); + c49_l194_action_invoke(&mut instance); + c50_l195_action_invoke(&mut instance); + c51_l196_action_invoke(&mut instance); + c52_l197_action_invoke(&mut instance); + c53_l199_action_invoke(&mut instance); + c54_l200_action_invoke(&mut instance); + c55_l201_action_invoke(&mut instance); + c56_l202_action_invoke(&mut instance); + c57_l204_action_invoke(&mut instance); + c58_l205_action_invoke(&mut instance); + c59_l206_action_invoke(&mut instance); + c60_l207_action_invoke(&mut instance); + c61_l209_action_invoke(&mut instance); + c62_l210_action_invoke(&mut instance); + c63_l211_action_invoke(&mut instance); + c64_l212_action_invoke(&mut instance); + c65_l214_action_invoke(&mut instance); + c66_l215_action_invoke(&mut instance); + c67_l216_action_invoke(&mut instance); + c68_l217_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/exports.rs b/lib/runtime/tests/spectests/exports.rs new file mode 100644 index 000000000..4f1bfb122 --- /dev/null +++ b/lib/runtime/tests/spectests/exports.rs @@ -0,0 +1,1394 @@ +// 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/exports.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 3 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0)) + (export \"a\" (func 0))) + "; + 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 4 + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); +} +fn create_module_2() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0)) + (export \"a\" (func 0)) + (export \"b\" (func 0))) + "; + 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_2(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 5 + +#[test] +fn test_module_2() { + let mut instance = create_module_2(); + // We group the calls together + start_module_2(&mut instance); +} +fn create_module_3() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0)) + (func (;1;) (type 0)) + (export \"a\" (func 0)) + (export \"b\" (func 1))) + "; + 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_3(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 7 + +#[test] +fn test_module_3() { + let mut instance = create_module_3(); + // We group the calls together + start_module_3(&mut instance); +} +fn create_module_4() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0)) + (export \"a\" (func 0))) + "; + 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_4(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 8 + +#[test] +fn test_module_4() { + let mut instance = create_module_4(); + // We group the calls together + start_module_4(&mut instance); +} +fn create_module_5() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0)) + (export \"a\" (func 0)) + (export \"b\" (func 0)) + (export \"c\" (func 0))) + "; + 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_5(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 9 + +#[test] +fn test_module_5() { + let mut instance = create_module_5(); + // We group the calls together + start_module_5(&mut instance); +} +fn create_module_6() -> Box { + let module_str = "(module + (type (;0;) (func (param i32))) + (func (;0;) (type 0) (param i32)) + (export \"a\" (func 0)) + (export \"b\" (func 0))) + "; + 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_6(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 10 + +#[test] +fn test_module_6() { + let mut instance = create_module_6(); + // We group the calls together + start_module_6(&mut instance); +} +fn create_module_7() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0)) + (export \"a\" (func 0))) + "; + 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_7(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 11 + +#[test] +fn test_module_7() { + let mut instance = create_module_7(); + // We group the calls together + start_module_7(&mut instance); +} +fn create_module_8() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0)) + (export \"a\" (func 0))) + "; + 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_8(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 12 + +#[test] +fn test_module_8() { + let mut instance = create_module_8(); + // We group the calls together + start_module_8(&mut instance); +} +fn create_module_9() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0)) + (export \"a\" (func 0))) + "; + 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_9(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 13 + +#[test] +fn test_module_9() { + let mut instance = create_module_9(); + // We group the calls together + start_module_9(&mut instance); +} +fn create_module_10() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0)) + (export \"a\" (func 0))) + "; + 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_10(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 14 + +#[test] +fn test_module_10() { + let mut instance = create_module_10(); + // We group the calls together + start_module_10(&mut instance); +} +fn create_module_11() -> Box { + let module_str = "(module + (type (;0;) (func)) + (func (;0;) (type 0)) + (export \"a\" (func 0))) + "; + 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_11(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 16 + +#[test] +fn test_module_11() { + let mut instance = create_module_11(); + // We group the calls together + start_module_11(&mut instance); +} +fn create_module_12() -> Box { + let module_str = "(module + (type (;0;) (func (param i32) (result i32))) + (func (;0;) (type 0) (param i32) (result i32) + get_local 0 + i32.const 1 + i32.add + return) + (export \"e\" (func 0))) + "; + 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_12(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 22 +fn c12_l22_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c12_l22_action_invoke"); + let result = instance.call("e", &[Value::I32(42 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(43 as i32)))); + result.map(|_| ()) +} + +// Line 23 +fn c13_l23_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c13_l23_action_invoke"); + let result = instance.call("e", &[Value::I32(42 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(43 as i32)))); + result.map(|_| ()) +} + +// Line 29 +#[test] +fn c14_l29_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 7, 5, 1, 1, 97, 0, 1, 10, 4, 1, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 33 +#[test] +fn c15_l33_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 7, 9, 2, 1, 97, 0, 0, 1, 97, 0, 0, 10, 4, 1, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 37 +#[test] +fn c16_l37_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 3, 2, 0, 0, 7, 9, 2, 1, 97, 0, 0, 1, 97, 0, 1, 10, 7, 2, 2, 0, 11, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 41 +#[test] +fn c17_l41_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, 9, 2, 1, 97, 0, 0, 1, 97, 3, 0, 10, 4, 1, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 45 +#[test] +fn c18_l45_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 7, 9, 2, 1, 97, 0, 0, 1, 97, 1, 0, 10, 4, 1, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 49 +#[test] +fn c19_l49_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 7, 9, 2, 1, 97, 0, 0, 1, 97, 2, 0, 10, 4, 1, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 56 + +#[test] +fn test_module_12() { + let mut instance = create_module_12(); + // We group the calls together + start_module_12(&mut instance); + c12_l22_action_invoke(&mut instance); + c13_l23_action_invoke(&mut instance); +} +fn create_module_13() -> Box { + let module_str = "(module + (global (;0;) i32 (i32.const 0)) + (export \"a\" (global 0))) + "; + 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_13(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 57 + +#[test] +fn test_module_13() { + let mut instance = create_module_13(); + // We group the calls together + start_module_13(&mut instance); +} +fn create_module_14() -> Box { + let module_str = "(module + (global (;0;) i32 (i32.const 0)) + (export \"a\" (global 0)) + (export \"b\" (global 0))) + "; + 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_14(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 58 + +#[test] +fn test_module_14() { + let mut instance = create_module_14(); + // We group the calls together + start_module_14(&mut instance); +} +fn create_module_15() -> Box { + let module_str = "(module + (global (;0;) i32 (i32.const 0)) + (global (;1;) i32 (i32.const 0)) + (export \"a\" (global 0)) + (export \"b\" (global 1))) + "; + 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_15(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 60 + +#[test] +fn test_module_15() { + let mut instance = create_module_15(); + // We group the calls together + start_module_15(&mut instance); +} +fn create_module_16() -> Box { + let module_str = "(module + (global (;0;) i32 (i32.const 0)) + (export \"a\" (global 0))) + "; + 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_16(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 61 + +#[test] +fn test_module_16() { + let mut instance = create_module_16(); + // We group the calls together + start_module_16(&mut instance); +} +fn create_module_17() -> Box { + let module_str = "(module + (global (;0;) i32 (i32.const 0)) + (export \"a\" (global 0))) + "; + 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_17(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 62 + +#[test] +fn test_module_17() { + let mut instance = create_module_17(); + // We group the calls together + start_module_17(&mut instance); +} +fn create_module_18() -> Box { + let module_str = "(module + (global (;0;) i32 (i32.const 0)) + (export \"a\" (global 0))) + "; + 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_18(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 63 + +#[test] +fn test_module_18() { + let mut instance = create_module_18(); + // We group the calls together + start_module_18(&mut instance); +} +fn create_module_19() -> Box { + let module_str = "(module + (global (;0;) i32 (i32.const 0)) + (export \"a\" (global 0))) + "; + 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_19(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 64 + +#[test] +fn test_module_19() { + let mut instance = create_module_19(); + // We group the calls together + start_module_19(&mut instance); +} +fn create_module_20() -> Box { + let module_str = "(module + (global (;0;) i32 (i32.const 0)) + (export \"a\" (global 0))) + "; + 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_20(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 65 + +#[test] +fn test_module_20() { + let mut instance = create_module_20(); + // We group the calls together + start_module_20(&mut instance); +} +fn create_module_21() -> Box { + let module_str = "(module + (global (;0;) i32 (i32.const 0)) + (export \"a\" (global 0))) + "; + 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_21(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 67 + +#[test] +fn test_module_21() { + let mut instance = create_module_21(); + // We group the calls together + start_module_21(&mut instance); +} +fn create_module_22() -> Box { + let module_str = "(module + (global (;0;) i32 (i32.const 42)) + (export \"e\" (global 0))) + "; + 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_22(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 71 + +// Line 72 + +// Line 78 +#[test] +fn c32_l78_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, 5, 1, 1, 97, 3, 1]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 82 +#[test] +fn c33_l82_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, 9, 2, 1, 97, 3, 0, 1, 97, 3, 0]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 86 +#[test] +fn c34_l86_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 11, 2, 127, 0, 65, 0, 11, 127, 0, 65, 0, 11, 7, 9, 2, 1, 97, 3, 0, 1, 97, 3, 1]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 90 +#[test] +fn c35_l90_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, 9, 2, 1, 97, 3, 0, 1, 97, 0, 0, 10, 4, 1, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 94 +#[test] +fn c36_l94_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, 9, 2, 1, 97, 3, 0, 1, 97, 1, 0]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 98 +#[test] +fn c37_l98_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 3, 1, 0, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, 9, 2, 1, 97, 3, 0, 1, 97, 2, 0]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 105 + +#[test] +fn test_module_22() { + let mut instance = create_module_22(); + // We group the calls together + start_module_22(&mut instance); +} +fn create_module_23() -> Box { + let module_str = "(module + (table (;0;) 0 anyfunc) + (export \"a\" (table 0))) + "; + 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_23(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 106 + +#[test] +fn test_module_23() { + let mut instance = create_module_23(); + // We group the calls together + start_module_23(&mut instance); +} +fn create_module_24() -> Box { + let module_str = "(module + (table (;0;) 0 anyfunc) + (export \"a\" (table 0)) + (export \"b\" (table 0))) + "; + 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_24(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 110 + +#[test] +fn test_module_24() { + let mut instance = create_module_24(); + // We group the calls together + start_module_24(&mut instance); +} +fn create_module_25() -> Box { + let module_str = "(module + (table (;0;) 0 anyfunc) + (export \"a\" (table 0))) + "; + 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_25(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 111 + +#[test] +fn test_module_25() { + let mut instance = create_module_25(); + // We group the calls together + start_module_25(&mut instance); +} +fn create_module_26() -> Box { + let module_str = "(module + (table (;0;) 0 1 anyfunc) + (export \"a\" (table 0))) + "; + 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_26(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 112 + +#[test] +fn test_module_26() { + let mut instance = create_module_26(); + // We group the calls together + start_module_26(&mut instance); +} +fn create_module_27() -> Box { + let module_str = "(module + (table (;0;) 0 anyfunc) + (export \"a\" (table 0))) + "; + 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_27(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 113 + +#[test] +fn test_module_27() { + let mut instance = create_module_27(); + // We group the calls together + start_module_27(&mut instance); +} +fn create_module_28() -> Box { + let module_str = "(module + (table (;0;) 0 1 anyfunc) + (export \"a\" (table 0))) + "; + 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_28(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 114 + +#[test] +fn test_module_28() { + let mut instance = create_module_28(); + // We group the calls together + start_module_28(&mut instance); +} +fn create_module_29() -> Box { + let module_str = "(module + (table (;0;) 0 anyfunc) + (export \"a\" (table 0))) + "; + 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_29(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 115 + +#[test] +fn test_module_29() { + let mut instance = create_module_29(); + // We group the calls together + start_module_29(&mut instance); +} +fn create_module_30() -> Box { + let module_str = "(module + (table (;0;) 0 1 anyfunc) + (export \"a\" (table 0))) + "; + 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_30(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 116 + +#[test] +fn test_module_30() { + let mut instance = create_module_30(); + // We group the calls together + start_module_30(&mut instance); +} +fn create_module_31() -> Box { + let module_str = "(module + (table (;0;) 0 anyfunc) + (export \"a\" (table 0))) + "; + 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_31(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 117 + +#[test] +fn test_module_31() { + let mut instance = create_module_31(); + // We group the calls together + start_module_31(&mut instance); +} +fn create_module_32() -> Box { + let module_str = "(module + (table (;0;) 0 1 anyfunc) + (export \"a\" (table 0))) + "; + 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_32(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 118 + +#[test] +fn test_module_32() { + let mut instance = create_module_32(); + // We group the calls together + start_module_32(&mut instance); +} +fn create_module_33() -> Box { + let module_str = "(module + (table (;0;) 0 anyfunc) + (export \"a\" (table 0))) + "; + 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_33(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 119 + +#[test] +fn test_module_33() { + let mut instance = create_module_33(); + // We group the calls together + start_module_33(&mut instance); +} +fn create_module_34() -> Box { + let module_str = "(module + (table (;0;) 0 1 anyfunc) + (export \"a\" (table 0))) + "; + 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_34(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 120 + +#[test] +fn test_module_34() { + let mut instance = create_module_34(); + // We group the calls together + start_module_34(&mut instance); +} +fn create_module_35() -> Box { + let module_str = "(module + (table (;0;) 0 anyfunc) + (export \"a\" (table 0))) + "; + 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_35(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 121 + +#[test] +fn test_module_35() { + let mut instance = create_module_35(); + // We group the calls together + start_module_35(&mut instance); +} +fn create_module_36() -> Box { + let module_str = "(module + (table (;0;) 0 1 anyfunc) + (export \"a\" (table 0))) + "; + 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_36(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 126 +#[test] +fn c52_l126_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 0, 7, 5, 1, 1, 97, 1, 1]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 130 +#[test] +fn c53_l130_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 0, 7, 9, 2, 1, 97, 1, 0, 1, 97, 1, 0]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 139 +#[test] +fn c54_l139_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 7, 9, 2, 1, 97, 1, 0, 1, 97, 0, 0, 10, 4, 1, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 143 +#[test] +fn c55_l143_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, 9, 2, 1, 97, 1, 0, 1, 97, 3, 0]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 147 +#[test] +fn c56_l147_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 0, 5, 3, 1, 0, 0, 7, 9, 2, 1, 97, 1, 0, 1, 97, 2, 0]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 154 + +#[test] +fn test_module_36() { + let mut instance = create_module_36(); + // We group the calls together + start_module_36(&mut instance); +} +fn create_module_37() -> Box { + let module_str = "(module + (memory (;0;) 0) + (export \"a\" (memory 0))) + "; + 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_37(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 155 + +#[test] +fn test_module_37() { + let mut instance = create_module_37(); + // We group the calls together + start_module_37(&mut instance); +} +fn create_module_38() -> Box { + let module_str = "(module + (memory (;0;) 0) + (export \"a\" (memory 0)) + (export \"b\" (memory 0))) + "; + 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_38(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 159 + +#[test] +fn test_module_38() { + let mut instance = create_module_38(); + // We group the calls together + start_module_38(&mut instance); +} +fn create_module_39() -> Box { + let module_str = "(module + (memory (;0;) 0) + (export \"a\" (memory 0))) + "; + 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_39(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 160 + +#[test] +fn test_module_39() { + let mut instance = create_module_39(); + // We group the calls together + start_module_39(&mut instance); +} +fn create_module_40() -> Box { + let module_str = "(module + (memory (;0;) 0 1) + (export \"a\" (memory 0))) + "; + 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_40(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 161 + +#[test] +fn test_module_40() { + let mut instance = create_module_40(); + // We group the calls together + start_module_40(&mut instance); +} +fn create_module_41() -> Box { + let module_str = "(module + (memory (;0;) 0) + (export \"a\" (memory 0))) + "; + 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_41(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 162 + +#[test] +fn test_module_41() { + let mut instance = create_module_41(); + // We group the calls together + start_module_41(&mut instance); +} +fn create_module_42() -> Box { + let module_str = "(module + (memory (;0;) 0 1) + (export \"a\" (memory 0))) + "; + 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_42(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 163 + +#[test] +fn test_module_42() { + let mut instance = create_module_42(); + // We group the calls together + start_module_42(&mut instance); +} +fn create_module_43() -> Box { + let module_str = "(module + (memory (;0;) 0) + (export \"a\" (memory 0))) + "; + 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_43(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 164 + +#[test] +fn test_module_43() { + let mut instance = create_module_43(); + // We group the calls together + start_module_43(&mut instance); +} +fn create_module_44() -> Box { + let module_str = "(module + (memory (;0;) 0 1) + (export \"a\" (memory 0))) + "; + 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_44(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 165 + +#[test] +fn test_module_44() { + let mut instance = create_module_44(); + // We group the calls together + start_module_44(&mut instance); +} +fn create_module_45() -> Box { + let module_str = "(module + (memory (;0;) 0) + (export \"a\" (memory 0))) + "; + 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_45(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 166 + +#[test] +fn test_module_45() { + let mut instance = create_module_45(); + // We group the calls together + start_module_45(&mut instance); +} +fn create_module_46() -> Box { + let module_str = "(module + (memory (;0;) 0 1) + (export \"a\" (memory 0))) + "; + 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_46(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 167 + +#[test] +fn test_module_46() { + let mut instance = create_module_46(); + // We group the calls together + start_module_46(&mut instance); +} +fn create_module_47() -> Box { + let module_str = "(module + (memory (;0;) 0) + (export \"a\" (memory 0))) + "; + 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_47(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 168 + +#[test] +fn test_module_47() { + let mut instance = create_module_47(); + // We group the calls together + start_module_47(&mut instance); +} +fn create_module_48() -> Box { + let module_str = "(module + (memory (;0;) 0 1) + (export \"a\" (memory 0))) + "; + 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_48(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 169 + +#[test] +fn test_module_48() { + let mut instance = create_module_48(); + // We group the calls together + start_module_48(&mut instance); +} +fn create_module_49() -> Box { + let module_str = "(module + (memory (;0;) 0) + (export \"a\" (memory 0))) + "; + 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_49(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 170 + +#[test] +fn test_module_49() { + let mut instance = create_module_49(); + // We group the calls together + start_module_49(&mut instance); +} +fn create_module_50() -> Box { + let module_str = "(module + (memory (;0;) 0 1) + (export \"a\" (memory 0))) + "; + 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_50(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 175 +#[test] +fn c71_l175_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 3, 1, 0, 0, 7, 5, 1, 1, 97, 2, 1]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 179 +#[test] +fn c72_l179_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 3, 1, 0, 0, 7, 9, 2, 1, 97, 2, 0, 1, 97, 2, 0]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 188 +#[test] +fn c73_l188_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 7, 9, 2, 1, 97, 2, 0, 1, 97, 0, 0, 10, 4, 1, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 192 +#[test] +fn c74_l192_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 3, 1, 0, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, 9, 2, 1, 97, 2, 0, 1, 97, 3, 0]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 196 +#[test] +fn c75_l196_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 0, 5, 3, 1, 0, 0, 7, 9, 2, 1, 97, 2, 0, 1, 97, 1, 0]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +#[test] +fn test_module_50() { + let mut instance = create_module_50(); + // We group the calls together + start_module_50(&mut instance); +} diff --git a/lib/runtime/tests/spectests/f32_.rs b/lib/runtime/tests/spectests/f32_.rs new file mode 100644 index 000000000..a818f3554 --- /dev/null +++ b/lib/runtime/tests/spectests/f32_.rs @@ -0,0 +1,25325 @@ +// 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_.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 5 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32) (result f32))) + (type (;1;) (func (param f32) (result f32))) + (func (;0;) (type 0) (param f32 f32) (result f32) + get_local 0 + get_local 1 + f32.add) + (func (;1;) (type 0) (param f32 f32) (result f32) + get_local 0 + get_local 1 + f32.sub) + (func (;2;) (type 0) (param f32 f32) (result f32) + get_local 0 + get_local 1 + f32.mul) + (func (;3;) (type 0) (param f32 f32) (result f32) + get_local 0 + get_local 1 + f32.div) + (func (;4;) (type 1) (param f32) (result f32) + get_local 0 + f32.sqrt) + (func (;5;) (type 0) (param f32 f32) (result f32) + get_local 0 + get_local 1 + f32.min) + (func (;6;) (type 0) (param f32 f32) (result f32) + get_local 0 + get_local 1 + f32.max) + (func (;7;) (type 1) (param f32) (result f32) + get_local 0 + f32.ceil) + (func (;8;) (type 1) (param f32) (result f32) + get_local 0 + f32.floor) + (func (;9;) (type 1) (param f32) (result f32) + get_local 0 + f32.trunc) + (func (;10;) (type 1) (param f32) (result f32) + get_local 0 + f32.nearest) + (export \"add\" (func 0)) + (export \"sub\" (func 1)) + (export \"mul\" (func 2)) + (export \"div\" (func 3)) + (export \"sqrt\" (func 4)) + (export \"min\" (func 5)) + (export \"max\" (func 6)) + (export \"ceil\" (func 7)) + (export \"floor\" (func 8)) + (export \"trunc\" (func 9)) + (export \"nearest\" (func 10))) + "; + 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 19 +fn c1_l19_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l19_action_invoke"); + let result = instance.call("add", &[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 20 +fn c2_l20_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l20_action_invoke"); + let result = instance.call("add", &[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 21 +fn c3_l21_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l21_action_invoke"); + let result = instance.call("add", &[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 22 +fn c4_l22_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l22_action_invoke"); + let result = instance.call("add", &[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 23 +fn c5_l23_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l23_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 24 +fn c6_l24_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l24_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 25 +fn c7_l25_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l25_action_invoke"); + let result = instance.call("add", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 26 +fn c8_l26_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l26_action_invoke"); + let result = instance.call("add", &[Value::F32((0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 27 +fn c9_l27_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l27_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 28 +fn c10_l28_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c10_l28_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 29 +fn c11_l29_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c11_l29_action_invoke"); + let result = instance.call("add", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 30 +fn c12_l30_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c12_l30_action_invoke"); + let result = instance.call("add", &[Value::F32((0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 31 +fn c13_l31_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c13_l31_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 32 +fn c14_l32_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c14_l32_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 33 +fn c15_l33_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c15_l33_action_invoke"); + let result = instance.call("add", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 34 +fn c16_l34_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c16_l34_action_invoke"); + let result = instance.call("add", &[Value::F32((0.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 35 +fn c17_l35_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c17_l35_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 36 +fn c18_l36_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c18_l36_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 37 +fn c19_l37_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c19_l37_action_invoke"); + let result = instance.call("add", &[Value::F32((0.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 38 +fn c20_l38_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c20_l38_action_invoke"); + let result = instance.call("add", &[Value::F32((0.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 39 +fn c21_l39_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c21_l39_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 40 +fn c22_l40_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c22_l40_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 41 +fn c23_l41_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c23_l41_action_invoke"); + let result = instance.call("add", &[Value::F32((0.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 42 +fn c24_l42_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c24_l42_action_invoke"); + let result = instance.call("add", &[Value::F32((0.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 43 +fn c25_l43_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c25_l43_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 44 +fn c26_l44_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c26_l44_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 45 +fn c27_l45_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c27_l45_action_invoke"); + let result = instance.call("add", &[Value::F32((0.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 46 +fn c28_l46_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c28_l46_action_invoke"); + let result = instance.call("add", &[Value::F32((0.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 47 +fn c29_l47_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c29_l47_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 48 +fn c30_l48_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c30_l48_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 49 +fn c31_l49_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c31_l49_action_invoke"); + let result = instance.call("add", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 50 +fn c32_l50_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c32_l50_action_invoke"); + let result = instance.call("add", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 51 +fn c33_l51_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c33_l51_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c33_l51_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 52 +fn c34_l52_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c34_l52_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c34_l52_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 53 +fn c35_l53_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c35_l53_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c35_l53_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 54 +fn c36_l54_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c36_l54_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c36_l54_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 55 +fn c37_l55_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c37_l55_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c37_l55_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 56 +fn c38_l56_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c38_l56_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c38_l56_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 57 +fn c39_l57_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c39_l57_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c39_l57_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 58 +fn c40_l58_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c40_l58_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c40_l58_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 59 +fn c41_l59_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c41_l59_action_invoke"); + let result = instance.call("add", &[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 60 +fn c42_l60_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c42_l60_action_invoke"); + let result = instance.call("add", &[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 61 +fn c43_l61_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c43_l61_action_invoke"); + let result = instance.call("add", &[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 62 +fn c44_l62_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c44_l62_action_invoke"); + let result = instance.call("add", &[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 63 +fn c45_l63_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c45_l63_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000003f32).to_bits())))); + result.map(|_| ()) +} + +// Line 64 +fn c46_l64_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c46_l64_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 65 +fn c47_l65_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c47_l65_action_invoke"); + let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 66 +fn c48_l66_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c48_l66_action_invoke"); + let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000003f32).to_bits())))); + result.map(|_| ()) +} + +// Line 67 +fn c49_l67_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c49_l67_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754945f32).to_bits())))); + result.map(|_| ()) +} + +// Line 68 +fn c50_l68_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c50_l68_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754942f32).to_bits())))); + result.map(|_| ()) +} + +// Line 69 +fn c51_l69_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c51_l69_action_invoke"); + let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754942f32).to_bits())))); + result.map(|_| ()) +} + +// Line 70 +fn c52_l70_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c52_l70_action_invoke"); + let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754945f32).to_bits())))); + result.map(|_| ()) +} + +// Line 71 +fn c53_l71_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c53_l71_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 72 +fn c54_l72_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c54_l72_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 73 +fn c55_l73_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c55_l73_action_invoke"); + let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 74 +fn c56_l74_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c56_l74_action_invoke"); + let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 75 +fn c57_l75_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c57_l75_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 76 +fn c58_l76_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c58_l76_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 77 +fn c59_l77_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c59_l77_action_invoke"); + let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 78 +fn c60_l78_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c60_l78_action_invoke"); + let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 79 +fn c61_l79_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c61_l79_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 80 +fn c62_l80_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c62_l80_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 81 +fn c63_l81_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c63_l81_action_invoke"); + let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 82 +fn c64_l82_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c64_l82_action_invoke"); + let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 83 +fn c65_l83_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c65_l83_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 84 +fn c66_l84_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c66_l84_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 85 +fn c67_l85_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c67_l85_action_invoke"); + let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 86 +fn c68_l86_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c68_l86_action_invoke"); + let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 87 +fn c69_l87_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c69_l87_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 88 +fn c70_l88_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c70_l88_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 89 +fn c71_l89_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c71_l89_action_invoke"); + let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 90 +fn c72_l90_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c72_l90_action_invoke"); + let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 91 +fn c73_l91_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c73_l91_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c73_l91_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 92 +fn c74_l92_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c74_l92_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c74_l92_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 93 +fn c75_l93_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c75_l93_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c75_l93_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 94 +fn c76_l94_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c76_l94_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c76_l94_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 95 +fn c77_l95_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c77_l95_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c77_l95_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 96 +fn c78_l96_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c78_l96_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c78_l96_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 97 +fn c79_l97_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c79_l97_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c79_l97_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 98 +fn c80_l98_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c80_l98_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c80_l98_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 99 +fn c81_l99_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c81_l99_action_invoke"); + let result = instance.call("add", &[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 100 +fn c82_l100_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c82_l100_action_invoke"); + let result = instance.call("add", &[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 101 +fn c83_l101_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c83_l101_action_invoke"); + let result = instance.call("add", &[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 102 +fn c84_l102_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c84_l102_action_invoke"); + let result = instance.call("add", &[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 103 +fn c85_l103_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c85_l103_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754945f32).to_bits())))); + result.map(|_| ()) +} + +// Line 104 +fn c86_l104_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c86_l104_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754942f32).to_bits())))); + result.map(|_| ()) +} + +// Line 105 +fn c87_l105_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c87_l105_action_invoke"); + let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754942f32).to_bits())))); + result.map(|_| ()) +} + +// Line 106 +fn c88_l106_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c88_l106_action_invoke"); + let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754945f32).to_bits())))); + result.map(|_| ()) +} + +// Line 107 +fn c89_l107_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c89_l107_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000023509887f32).to_bits())))); + result.map(|_| ()) +} + +// Line 108 +fn c90_l108_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c90_l108_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 109 +fn c91_l109_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c91_l109_action_invoke"); + let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 110 +fn c92_l110_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c92_l110_action_invoke"); + let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000023509887f32).to_bits())))); + result.map(|_| ()) +} + +// Line 111 +fn c93_l111_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c93_l111_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 112 +fn c94_l112_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c94_l112_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 113 +fn c95_l113_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c95_l113_action_invoke"); + let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 114 +fn c96_l114_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c96_l114_action_invoke"); + let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 115 +fn c97_l115_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c97_l115_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 116 +fn c98_l116_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c98_l116_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 117 +fn c99_l117_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c99_l117_action_invoke"); + let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 118 +fn c100_l118_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c100_l118_action_invoke"); + let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 119 +fn c101_l119_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c101_l119_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 120 +fn c102_l120_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c102_l120_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 121 +fn c103_l121_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c103_l121_action_invoke"); + let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 122 +fn c104_l122_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c104_l122_action_invoke"); + let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 123 +fn c105_l123_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c105_l123_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 124 +fn c106_l124_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c106_l124_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 125 +fn c107_l125_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c107_l125_action_invoke"); + let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 126 +fn c108_l126_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c108_l126_action_invoke"); + let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 127 +fn c109_l127_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c109_l127_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 128 +fn c110_l128_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c110_l128_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 129 +fn c111_l129_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c111_l129_action_invoke"); + let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 130 +fn c112_l130_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c112_l130_action_invoke"); + let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 131 +fn c113_l131_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c113_l131_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c113_l131_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 132 +fn c114_l132_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c114_l132_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c114_l132_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 133 +fn c115_l133_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c115_l133_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c115_l133_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 134 +fn c116_l134_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c116_l134_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c116_l134_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 135 +fn c117_l135_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c117_l135_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c117_l135_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 136 +fn c118_l136_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c118_l136_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c118_l136_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 137 +fn c119_l137_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c119_l137_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c119_l137_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 138 +fn c120_l138_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c120_l138_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c120_l138_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 139 +fn c121_l139_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c121_l139_action_invoke"); + let result = instance.call("add", &[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 140 +fn c122_l140_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c122_l140_action_invoke"); + let result = instance.call("add", &[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 141 +fn c123_l141_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c123_l141_action_invoke"); + let result = instance.call("add", &[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 142 +fn c124_l142_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c124_l142_action_invoke"); + let result = instance.call("add", &[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 143 +fn c125_l143_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c125_l143_action_invoke"); + let result = instance.call("add", &[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 144 +fn c126_l144_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c126_l144_action_invoke"); + let result = instance.call("add", &[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 145 +fn c127_l145_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c127_l145_action_invoke"); + let result = instance.call("add", &[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 146 +fn c128_l146_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c128_l146_action_invoke"); + let result = instance.call("add", &[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 147 +fn c129_l147_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c129_l147_action_invoke"); + let result = instance.call("add", &[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 148 +fn c130_l148_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c130_l148_action_invoke"); + let result = instance.call("add", &[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 149 +fn c131_l149_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c131_l149_action_invoke"); + let result = instance.call("add", &[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 150 +fn c132_l150_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c132_l150_action_invoke"); + let result = instance.call("add", &[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 151 +fn c133_l151_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c133_l151_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 152 +fn c134_l152_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c134_l152_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 153 +fn c135_l153_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c135_l153_action_invoke"); + let result = instance.call("add", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 154 +fn c136_l154_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c136_l154_action_invoke"); + let result = instance.call("add", &[Value::F32((0.5f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 155 +fn c137_l155_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c137_l155_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.5f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 156 +fn c138_l156_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c138_l156_action_invoke"); + let result = instance.call("add", &[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 157 +fn c139_l157_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c139_l157_action_invoke"); + let result = instance.call("add", &[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 158 +fn c140_l158_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c140_l158_action_invoke"); + let result = instance.call("add", &[Value::F32((0.5f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 159 +fn c141_l159_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c141_l159_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.5f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6.7831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 160 +fn c142_l160_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c142_l160_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.5f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((5.7831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 161 +fn c143_l161_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c143_l161_action_invoke"); + let result = instance.call("add", &[Value::F32((0.5f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-5.7831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 162 +fn c144_l162_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c144_l162_action_invoke"); + let result = instance.call("add", &[Value::F32((0.5f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((6.7831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 163 +fn c145_l163_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c145_l163_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.5f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 164 +fn c146_l164_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c146_l164_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.5f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 165 +fn c147_l165_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c147_l165_action_invoke"); + let result = instance.call("add", &[Value::F32((0.5f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 166 +fn c148_l166_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c148_l166_action_invoke"); + let result = instance.call("add", &[Value::F32((0.5f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 167 +fn c149_l167_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c149_l167_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 168 +fn c150_l168_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c150_l168_action_invoke"); + let result = instance.call("add", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 169 +fn c151_l169_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c151_l169_action_invoke"); + let result = instance.call("add", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 170 +fn c152_l170_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c152_l170_action_invoke"); + let result = instance.call("add", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 171 +fn c153_l171_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c153_l171_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c153_l171_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 172 +fn c154_l172_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c154_l172_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c154_l172_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 173 +fn c155_l173_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c155_l173_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c155_l173_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 174 +fn c156_l174_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c156_l174_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c156_l174_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 175 +fn c157_l175_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c157_l175_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c157_l175_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 176 +fn c158_l176_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c158_l176_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c158_l176_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 177 +fn c159_l177_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c159_l177_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c159_l177_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 178 +fn c160_l178_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c160_l178_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c160_l178_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 179 +fn c161_l179_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c161_l179_action_invoke"); + let result = instance.call("add", &[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 180 +fn c162_l180_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c162_l180_action_invoke"); + let result = instance.call("add", &[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 181 +fn c163_l181_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c163_l181_action_invoke"); + let result = instance.call("add", &[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 182 +fn c164_l182_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c164_l182_action_invoke"); + let result = instance.call("add", &[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 183 +fn c165_l183_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c165_l183_action_invoke"); + let result = instance.call("add", &[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 184 +fn c166_l184_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c166_l184_action_invoke"); + let result = instance.call("add", &[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 185 +fn c167_l185_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c167_l185_action_invoke"); + let result = instance.call("add", &[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 186 +fn c168_l186_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c168_l186_action_invoke"); + let result = instance.call("add", &[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 187 +fn c169_l187_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c169_l187_action_invoke"); + let result = instance.call("add", &[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 188 +fn c170_l188_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c170_l188_action_invoke"); + let result = instance.call("add", &[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 189 +fn c171_l189_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c171_l189_action_invoke"); + let result = instance.call("add", &[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 190 +fn c172_l190_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c172_l190_action_invoke"); + let result = instance.call("add", &[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 191 +fn c173_l191_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c173_l191_action_invoke"); + let result = instance.call("add", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 192 +fn c174_l192_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c174_l192_action_invoke"); + let result = instance.call("add", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 193 +fn c175_l193_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c175_l193_action_invoke"); + let result = instance.call("add", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 194 +fn c176_l194_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c176_l194_action_invoke"); + let result = instance.call("add", &[Value::F32((1.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 195 +fn c177_l195_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c177_l195_action_invoke"); + let result = instance.call("add", &[Value::F32((-1.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-2.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 196 +fn c178_l196_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c178_l196_action_invoke"); + let result = instance.call("add", &[Value::F32((-1.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 197 +fn c179_l197_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c179_l197_action_invoke"); + let result = instance.call("add", &[Value::F32((1.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 198 +fn c180_l198_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c180_l198_action_invoke"); + let result = instance.call("add", &[Value::F32((1.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((2.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 199 +fn c181_l199_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c181_l199_action_invoke"); + let result = instance.call("add", &[Value::F32((-1.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-7.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 200 +fn c182_l200_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c182_l200_action_invoke"); + let result = instance.call("add", &[Value::F32((-1.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((5.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 201 +fn c183_l201_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c183_l201_action_invoke"); + let result = instance.call("add", &[Value::F32((1.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-5.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 202 +fn c184_l202_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c184_l202_action_invoke"); + let result = instance.call("add", &[Value::F32((1.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((7.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 203 +fn c185_l203_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c185_l203_action_invoke"); + let result = instance.call("add", &[Value::F32((-1.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 204 +fn c186_l204_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c186_l204_action_invoke"); + let result = instance.call("add", &[Value::F32((-1.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 205 +fn c187_l205_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c187_l205_action_invoke"); + let result = instance.call("add", &[Value::F32((1.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 206 +fn c188_l206_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c188_l206_action_invoke"); + let result = instance.call("add", &[Value::F32((1.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 207 +fn c189_l207_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c189_l207_action_invoke"); + let result = instance.call("add", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 208 +fn c190_l208_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c190_l208_action_invoke"); + let result = instance.call("add", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 209 +fn c191_l209_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c191_l209_action_invoke"); + let result = instance.call("add", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 210 +fn c192_l210_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c192_l210_action_invoke"); + let result = instance.call("add", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 211 +fn c193_l211_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c193_l211_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c193_l211_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 212 +fn c194_l212_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c194_l212_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c194_l212_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 213 +fn c195_l213_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c195_l213_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c195_l213_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 214 +fn c196_l214_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c196_l214_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c196_l214_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 215 +fn c197_l215_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c197_l215_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c197_l215_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 216 +fn c198_l216_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c198_l216_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c198_l216_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 217 +fn c199_l217_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c199_l217_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c199_l217_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 218 +fn c200_l218_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c200_l218_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c200_l218_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 219 +fn c201_l219_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c201_l219_action_invoke"); + let result = instance.call("add", &[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 220 +fn c202_l220_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c202_l220_action_invoke"); + let result = instance.call("add", &[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 221 +fn c203_l221_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c203_l221_action_invoke"); + let result = instance.call("add", &[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 222 +fn c204_l222_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c204_l222_action_invoke"); + let result = instance.call("add", &[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 223 +fn c205_l223_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c205_l223_action_invoke"); + let result = instance.call("add", &[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 224 +fn c206_l224_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c206_l224_action_invoke"); + let result = instance.call("add", &[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 225 +fn c207_l225_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c207_l225_action_invoke"); + let result = instance.call("add", &[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 226 +fn c208_l226_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c208_l226_action_invoke"); + let result = instance.call("add", &[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 227 +fn c209_l227_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c209_l227_action_invoke"); + let result = instance.call("add", &[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 228 +fn c210_l228_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c210_l228_action_invoke"); + let result = instance.call("add", &[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 229 +fn c211_l229_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c211_l229_action_invoke"); + let result = instance.call("add", &[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 230 +fn c212_l230_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c212_l230_action_invoke"); + let result = instance.call("add", &[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 231 +fn c213_l231_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c213_l231_action_invoke"); + let result = instance.call("add", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6.7831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 232 +fn c214_l232_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c214_l232_action_invoke"); + let result = instance.call("add", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-5.7831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 233 +fn c215_l233_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c215_l233_action_invoke"); + let result = instance.call("add", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((5.7831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 234 +fn c216_l234_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c216_l234_action_invoke"); + let result = instance.call("add", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((6.7831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 235 +fn c217_l235_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c217_l235_action_invoke"); + let result = instance.call("add", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-7.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 236 +fn c218_l236_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c218_l236_action_invoke"); + let result = instance.call("add", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-5.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 237 +fn c219_l237_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c219_l237_action_invoke"); + let result = instance.call("add", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((5.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 238 +fn c220_l238_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c220_l238_action_invoke"); + let result = instance.call("add", &[Value::F32((6.2831855f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((7.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 239 +fn c221_l239_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c221_l239_action_invoke"); + let result = instance.call("add", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-12.566371f32).to_bits())))); + result.map(|_| ()) +} + +// Line 240 +fn c222_l240_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c222_l240_action_invoke"); + let result = instance.call("add", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 241 +fn c223_l241_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c223_l241_action_invoke"); + let result = instance.call("add", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 242 +fn c224_l242_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c224_l242_action_invoke"); + let result = instance.call("add", &[Value::F32((6.2831855f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((12.566371f32).to_bits())))); + result.map(|_| ()) +} + +// Line 243 +fn c225_l243_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c225_l243_action_invoke"); + let result = instance.call("add", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 244 +fn c226_l244_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c226_l244_action_invoke"); + let result = instance.call("add", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 245 +fn c227_l245_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c227_l245_action_invoke"); + let result = instance.call("add", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 246 +fn c228_l246_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c228_l246_action_invoke"); + let result = instance.call("add", &[Value::F32((6.2831855f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 247 +fn c229_l247_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c229_l247_action_invoke"); + let result = instance.call("add", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 248 +fn c230_l248_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c230_l248_action_invoke"); + let result = instance.call("add", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 249 +fn c231_l249_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c231_l249_action_invoke"); + let result = instance.call("add", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 250 +fn c232_l250_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c232_l250_action_invoke"); + let result = instance.call("add", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 251 +fn c233_l251_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c233_l251_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c233_l251_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 252 +fn c234_l252_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c234_l252_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c234_l252_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 253 +fn c235_l253_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c235_l253_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c235_l253_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 254 +fn c236_l254_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c236_l254_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c236_l254_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 255 +fn c237_l255_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c237_l255_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c237_l255_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 256 +fn c238_l256_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c238_l256_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c238_l256_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 257 +fn c239_l257_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c239_l257_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c239_l257_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 258 +fn c240_l258_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c240_l258_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c240_l258_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 259 +fn c241_l259_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c241_l259_action_invoke"); + let result = instance.call("add", &[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 260 +fn c242_l260_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c242_l260_action_invoke"); + let result = instance.call("add", &[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 261 +fn c243_l261_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c243_l261_action_invoke"); + let result = instance.call("add", &[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 262 +fn c244_l262_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c244_l262_action_invoke"); + let result = instance.call("add", &[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 263 +fn c245_l263_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c245_l263_action_invoke"); + let result = instance.call("add", &[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 264 +fn c246_l264_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c246_l264_action_invoke"); + let result = instance.call("add", &[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 265 +fn c247_l265_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c247_l265_action_invoke"); + let result = instance.call("add", &[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 266 +fn c248_l266_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c248_l266_action_invoke"); + let result = instance.call("add", &[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 267 +fn c249_l267_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c249_l267_action_invoke"); + let result = instance.call("add", &[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 268 +fn c250_l268_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c250_l268_action_invoke"); + let result = instance.call("add", &[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 269 +fn c251_l269_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c251_l269_action_invoke"); + let result = instance.call("add", &[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 270 +fn c252_l270_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c252_l270_action_invoke"); + let result = instance.call("add", &[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 271 +fn c253_l271_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c253_l271_action_invoke"); + let result = instance.call("add", &[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 272 +fn c254_l272_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c254_l272_action_invoke"); + let result = instance.call("add", &[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 273 +fn c255_l273_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c255_l273_action_invoke"); + let result = instance.call("add", &[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 274 +fn c256_l274_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c256_l274_action_invoke"); + let result = instance.call("add", &[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 275 +fn c257_l275_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c257_l275_action_invoke"); + let result = instance.call("add", &[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 276 +fn c258_l276_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c258_l276_action_invoke"); + let result = instance.call("add", &[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 277 +fn c259_l277_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c259_l277_action_invoke"); + let result = instance.call("add", &[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 278 +fn c260_l278_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c260_l278_action_invoke"); + let result = instance.call("add", &[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 279 +fn c261_l279_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c261_l279_action_invoke"); + let result = instance.call("add", &[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 280 +fn c262_l280_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c262_l280_action_invoke"); + let result = instance.call("add", &[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 281 +fn c263_l281_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c263_l281_action_invoke"); + let result = instance.call("add", &[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 282 +fn c264_l282_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c264_l282_action_invoke"); + let result = instance.call("add", &[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 283 +fn c265_l283_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c265_l283_action_invoke"); + let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 284 +fn c266_l284_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c266_l284_action_invoke"); + let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 285 +fn c267_l285_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c267_l285_action_invoke"); + let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 286 +fn c268_l286_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c268_l286_action_invoke"); + let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 287 +fn c269_l287_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c269_l287_action_invoke"); + let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 288 +fn c270_l288_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c270_l288_action_invoke"); + let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 289 +fn c271_l289_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c271_l289_action_invoke"); + let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 290 +fn c272_l290_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c272_l290_action_invoke"); + let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 291 +fn c273_l291_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c273_l291_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c273_l291_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 292 +fn c274_l292_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c274_l292_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c274_l292_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 293 +fn c275_l293_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c275_l293_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c275_l293_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 294 +fn c276_l294_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c276_l294_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c276_l294_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 295 +fn c277_l295_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c277_l295_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c277_l295_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 296 +fn c278_l296_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c278_l296_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c278_l296_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 297 +fn c279_l297_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c279_l297_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c279_l297_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 298 +fn c280_l298_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c280_l298_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c280_l298_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 299 +fn c281_l299_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c281_l299_action_invoke"); + let result = instance.call("add", &[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 300 +fn c282_l300_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c282_l300_action_invoke"); + let result = instance.call("add", &[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 301 +fn c283_l301_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c283_l301_action_invoke"); + let result = instance.call("add", &[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 302 +fn c284_l302_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c284_l302_action_invoke"); + let result = instance.call("add", &[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 303 +fn c285_l303_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c285_l303_action_invoke"); + let result = instance.call("add", &[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 304 +fn c286_l304_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c286_l304_action_invoke"); + let result = instance.call("add", &[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 305 +fn c287_l305_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c287_l305_action_invoke"); + let result = instance.call("add", &[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 306 +fn c288_l306_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c288_l306_action_invoke"); + let result = instance.call("add", &[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 307 +fn c289_l307_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c289_l307_action_invoke"); + let result = instance.call("add", &[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 308 +fn c290_l308_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c290_l308_action_invoke"); + let result = instance.call("add", &[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 309 +fn c291_l309_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c291_l309_action_invoke"); + let result = instance.call("add", &[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 310 +fn c292_l310_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c292_l310_action_invoke"); + let result = instance.call("add", &[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 311 +fn c293_l311_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c293_l311_action_invoke"); + let result = instance.call("add", &[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 312 +fn c294_l312_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c294_l312_action_invoke"); + let result = instance.call("add", &[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 313 +fn c295_l313_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c295_l313_action_invoke"); + let result = instance.call("add", &[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 314 +fn c296_l314_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c296_l314_action_invoke"); + let result = instance.call("add", &[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 315 +fn c297_l315_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c297_l315_action_invoke"); + let result = instance.call("add", &[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 316 +fn c298_l316_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c298_l316_action_invoke"); + let result = instance.call("add", &[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 317 +fn c299_l317_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c299_l317_action_invoke"); + let result = instance.call("add", &[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 318 +fn c300_l318_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c300_l318_action_invoke"); + let result = instance.call("add", &[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 319 +fn c301_l319_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c301_l319_action_invoke"); + let result = instance.call("add", &[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 320 +fn c302_l320_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c302_l320_action_invoke"); + let result = instance.call("add", &[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 321 +fn c303_l321_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c303_l321_action_invoke"); + let result = instance.call("add", &[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 322 +fn c304_l322_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c304_l322_action_invoke"); + let result = instance.call("add", &[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 323 +fn c305_l323_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c305_l323_action_invoke"); + let result = instance.call("add", &[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 324 +fn c306_l324_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c306_l324_action_invoke"); + let result = instance.call("add", &[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 325 +fn c307_l325_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c307_l325_action_invoke"); + let result = instance.call("add", &[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 326 +fn c308_l326_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c308_l326_action_invoke"); + let result = instance.call("add", &[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 327 +fn c309_l327_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c309_l327_action_invoke"); + let result = instance.call("add", &[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 328 +fn c310_l328_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c310_l328_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c310_l328_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 329 +fn c311_l329_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c311_l329_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c311_l329_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 330 +fn c312_l330_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c312_l330_action_invoke"); + let result = instance.call("add", &[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 331 +fn c313_l331_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c313_l331_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c313_l331_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 332 +fn c314_l332_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c314_l332_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c314_l332_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 333 +fn c315_l333_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c315_l333_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c315_l333_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 334 +fn c316_l334_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c316_l334_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c316_l334_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 335 +fn c317_l335_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c317_l335_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c317_l335_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 336 +fn c318_l336_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c318_l336_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c318_l336_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 337 +fn c319_l337_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c319_l337_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c319_l337_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 338 +fn c320_l338_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c320_l338_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c320_l338_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 339 +fn c321_l339_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c321_l339_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c321_l339_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 340 +fn c322_l340_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c322_l340_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c322_l340_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 341 +fn c323_l341_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c323_l341_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c323_l341_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 342 +fn c324_l342_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c324_l342_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c324_l342_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 343 +fn c325_l343_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c325_l343_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c325_l343_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 344 +fn c326_l344_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c326_l344_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c326_l344_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 345 +fn c327_l345_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c327_l345_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c327_l345_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 346 +fn c328_l346_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c328_l346_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c328_l346_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 347 +fn c329_l347_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c329_l347_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c329_l347_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 348 +fn c330_l348_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c330_l348_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c330_l348_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 349 +fn c331_l349_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c331_l349_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c331_l349_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 350 +fn c332_l350_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c332_l350_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c332_l350_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 351 +fn c333_l351_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c333_l351_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c333_l351_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 352 +fn c334_l352_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c334_l352_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c334_l352_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 353 +fn c335_l353_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c335_l353_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c335_l353_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 354 +fn c336_l354_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c336_l354_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c336_l354_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 355 +fn c337_l355_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c337_l355_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c337_l355_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 356 +fn c338_l356_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c338_l356_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c338_l356_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 357 +fn c339_l357_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c339_l357_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c339_l357_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 358 +fn c340_l358_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c340_l358_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c340_l358_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 359 +fn c341_l359_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c341_l359_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c341_l359_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 360 +fn c342_l360_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c342_l360_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c342_l360_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 361 +fn c343_l361_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c343_l361_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c343_l361_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 362 +fn c344_l362_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c344_l362_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c344_l362_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 363 +fn c345_l363_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c345_l363_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c345_l363_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 364 +fn c346_l364_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c346_l364_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c346_l364_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 365 +fn c347_l365_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c347_l365_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c347_l365_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 366 +fn c348_l366_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c348_l366_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c348_l366_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 367 +fn c349_l367_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c349_l367_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c349_l367_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 368 +fn c350_l368_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c350_l368_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c350_l368_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 369 +fn c351_l369_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c351_l369_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c351_l369_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 370 +fn c352_l370_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c352_l370_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c352_l370_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 371 +fn c353_l371_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c353_l371_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c353_l371_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 372 +fn c354_l372_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c354_l372_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c354_l372_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 373 +fn c355_l373_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c355_l373_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c355_l373_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 374 +fn c356_l374_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c356_l374_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c356_l374_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 375 +fn c357_l375_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c357_l375_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c357_l375_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 376 +fn c358_l376_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c358_l376_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c358_l376_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 377 +fn c359_l377_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c359_l377_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c359_l377_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 378 +fn c360_l378_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c360_l378_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c360_l378_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 379 +fn c361_l379_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c361_l379_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c361_l379_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 380 +fn c362_l380_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c362_l380_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c362_l380_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 381 +fn c363_l381_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c363_l381_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c363_l381_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 382 +fn c364_l382_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c364_l382_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c364_l382_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 383 +fn c365_l383_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c365_l383_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c365_l383_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 384 +fn c366_l384_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c366_l384_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c366_l384_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 385 +fn c367_l385_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c367_l385_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c367_l385_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 386 +fn c368_l386_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c368_l386_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c368_l386_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 387 +fn c369_l387_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c369_l387_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c369_l387_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 388 +fn c370_l388_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c370_l388_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c370_l388_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 389 +fn c371_l389_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c371_l389_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c371_l389_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 390 +fn c372_l390_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c372_l390_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c372_l390_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 391 +fn c373_l391_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c373_l391_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c373_l391_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 392 +fn c374_l392_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c374_l392_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c374_l392_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 393 +fn c375_l393_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c375_l393_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c375_l393_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 394 +fn c376_l394_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c376_l394_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c376_l394_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 395 +fn c377_l395_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c377_l395_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c377_l395_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 396 +fn c378_l396_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c378_l396_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c378_l396_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 397 +fn c379_l397_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c379_l397_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c379_l397_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 398 +fn c380_l398_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c380_l398_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c380_l398_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 399 +fn c381_l399_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c381_l399_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c381_l399_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 400 +fn c382_l400_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c382_l400_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c382_l400_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 401 +fn c383_l401_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c383_l401_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c383_l401_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 402 +fn c384_l402_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c384_l402_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c384_l402_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 403 +fn c385_l403_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c385_l403_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c385_l403_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 404 +fn c386_l404_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c386_l404_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c386_l404_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 405 +fn c387_l405_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c387_l405_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c387_l405_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 406 +fn c388_l406_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c388_l406_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c388_l406_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 407 +fn c389_l407_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c389_l407_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c389_l407_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 408 +fn c390_l408_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c390_l408_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c390_l408_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 409 +fn c391_l409_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c391_l409_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c391_l409_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 410 +fn c392_l410_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c392_l410_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c392_l410_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 411 +fn c393_l411_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c393_l411_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c393_l411_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 412 +fn c394_l412_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c394_l412_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c394_l412_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 413 +fn c395_l413_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c395_l413_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c395_l413_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 414 +fn c396_l414_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c396_l414_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c396_l414_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 415 +fn c397_l415_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c397_l415_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c397_l415_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 416 +fn c398_l416_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c398_l416_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c398_l416_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 417 +fn c399_l417_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c399_l417_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c399_l417_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 418 +fn c400_l418_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c400_l418_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c400_l418_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 419 +fn c401_l419_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c401_l419_action_invoke"); + let result = instance.call("sub", &[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 420 +fn c402_l420_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c402_l420_action_invoke"); + let result = instance.call("sub", &[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 421 +fn c403_l421_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c403_l421_action_invoke"); + let result = instance.call("sub", &[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 422 +fn c404_l422_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c404_l422_action_invoke"); + let result = instance.call("sub", &[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 423 +fn c405_l423_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c405_l423_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 424 +fn c406_l424_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c406_l424_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 425 +fn c407_l425_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c407_l425_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 426 +fn c408_l426_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c408_l426_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 427 +fn c409_l427_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c409_l427_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 428 +fn c410_l428_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c410_l428_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 429 +fn c411_l429_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c411_l429_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 430 +fn c412_l430_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c412_l430_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 431 +fn c413_l431_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c413_l431_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 432 +fn c414_l432_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c414_l432_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 433 +fn c415_l433_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c415_l433_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 434 +fn c416_l434_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c416_l434_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 435 +fn c417_l435_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c417_l435_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 436 +fn c418_l436_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c418_l436_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 437 +fn c419_l437_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c419_l437_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 438 +fn c420_l438_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c420_l438_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 439 +fn c421_l439_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c421_l439_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 440 +fn c422_l440_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c422_l440_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 441 +fn c423_l441_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c423_l441_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 442 +fn c424_l442_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c424_l442_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 443 +fn c425_l443_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c425_l443_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 444 +fn c426_l444_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c426_l444_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 445 +fn c427_l445_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c427_l445_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 446 +fn c428_l446_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c428_l446_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 447 +fn c429_l447_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c429_l447_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 448 +fn c430_l448_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c430_l448_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 449 +fn c431_l449_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c431_l449_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 450 +fn c432_l450_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c432_l450_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 451 +fn c433_l451_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c433_l451_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c433_l451_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 452 +fn c434_l452_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c434_l452_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c434_l452_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 453 +fn c435_l453_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c435_l453_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c435_l453_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 454 +fn c436_l454_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c436_l454_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c436_l454_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 455 +fn c437_l455_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c437_l455_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c437_l455_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 456 +fn c438_l456_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c438_l456_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c438_l456_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 457 +fn c439_l457_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c439_l457_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c439_l457_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 458 +fn c440_l458_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c440_l458_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c440_l458_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 459 +fn c441_l459_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c441_l459_action_invoke"); + let result = instance.call("sub", &[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 460 +fn c442_l460_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c442_l460_action_invoke"); + let result = instance.call("sub", &[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 461 +fn c443_l461_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c443_l461_action_invoke"); + let result = instance.call("sub", &[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 462 +fn c444_l462_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c444_l462_action_invoke"); + let result = instance.call("sub", &[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 463 +fn c445_l463_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c445_l463_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 464 +fn c446_l464_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c446_l464_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000003f32).to_bits())))); + result.map(|_| ()) +} + +// Line 465 +fn c447_l465_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c447_l465_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000003f32).to_bits())))); + result.map(|_| ()) +} + +// Line 466 +fn c448_l466_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c448_l466_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 467 +fn c449_l467_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c449_l467_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754942f32).to_bits())))); + result.map(|_| ()) +} + +// Line 468 +fn c450_l468_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c450_l468_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754945f32).to_bits())))); + result.map(|_| ()) +} + +// Line 469 +fn c451_l469_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c451_l469_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754945f32).to_bits())))); + result.map(|_| ()) +} + +// Line 470 +fn c452_l470_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c452_l470_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754942f32).to_bits())))); + result.map(|_| ()) +} + +// Line 471 +fn c453_l471_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c453_l471_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 472 +fn c454_l472_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c454_l472_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 473 +fn c455_l473_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c455_l473_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 474 +fn c456_l474_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c456_l474_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 475 +fn c457_l475_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c457_l475_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 476 +fn c458_l476_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c458_l476_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 477 +fn c459_l477_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c459_l477_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 478 +fn c460_l478_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c460_l478_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 479 +fn c461_l479_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c461_l479_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 480 +fn c462_l480_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c462_l480_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 481 +fn c463_l481_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c463_l481_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 482 +fn c464_l482_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c464_l482_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 483 +fn c465_l483_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c465_l483_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 484 +fn c466_l484_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c466_l484_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 485 +fn c467_l485_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c467_l485_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 486 +fn c468_l486_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c468_l486_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 487 +fn c469_l487_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c469_l487_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 488 +fn c470_l488_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c470_l488_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 489 +fn c471_l489_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c471_l489_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 490 +fn c472_l490_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c472_l490_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 491 +fn c473_l491_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c473_l491_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c473_l491_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 492 +fn c474_l492_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c474_l492_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c474_l492_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 493 +fn c475_l493_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c475_l493_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c475_l493_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 494 +fn c476_l494_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c476_l494_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c476_l494_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 495 +fn c477_l495_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c477_l495_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c477_l495_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 496 +fn c478_l496_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c478_l496_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c478_l496_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 497 +fn c479_l497_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c479_l497_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c479_l497_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 498 +fn c480_l498_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c480_l498_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c480_l498_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 499 +fn c481_l499_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c481_l499_action_invoke"); + let result = instance.call("sub", &[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 500 +fn c482_l500_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c482_l500_action_invoke"); + let result = instance.call("sub", &[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 501 +fn c483_l501_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c483_l501_action_invoke"); + let result = instance.call("sub", &[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 502 +fn c484_l502_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c484_l502_action_invoke"); + let result = instance.call("sub", &[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 503 +fn c485_l503_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c485_l503_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754942f32).to_bits())))); + result.map(|_| ()) +} + +// Line 504 +fn c486_l504_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c486_l504_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754945f32).to_bits())))); + result.map(|_| ()) +} + +// Line 505 +fn c487_l505_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c487_l505_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754945f32).to_bits())))); + result.map(|_| ()) +} + +// Line 506 +fn c488_l506_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c488_l506_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754942f32).to_bits())))); + result.map(|_| ()) +} + +// Line 507 +fn c489_l507_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c489_l507_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 508 +fn c490_l508_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c490_l508_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000023509887f32).to_bits())))); + result.map(|_| ()) +} + +// Line 509 +fn c491_l509_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c491_l509_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000023509887f32).to_bits())))); + result.map(|_| ()) +} + +// Line 510 +fn c492_l510_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c492_l510_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 511 +fn c493_l511_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c493_l511_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 512 +fn c494_l512_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c494_l512_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 513 +fn c495_l513_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c495_l513_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 514 +fn c496_l514_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c496_l514_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 515 +fn c497_l515_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c497_l515_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 516 +fn c498_l516_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c498_l516_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 517 +fn c499_l517_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c499_l517_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 518 +fn c500_l518_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c500_l518_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 519 +fn c501_l519_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c501_l519_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 520 +fn c502_l520_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c502_l520_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 521 +fn c503_l521_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c503_l521_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 522 +fn c504_l522_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c504_l522_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 523 +fn c505_l523_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c505_l523_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 524 +fn c506_l524_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c506_l524_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 525 +fn c507_l525_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c507_l525_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 526 +fn c508_l526_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c508_l526_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 527 +fn c509_l527_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c509_l527_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 528 +fn c510_l528_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c510_l528_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 529 +fn c511_l529_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c511_l529_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 530 +fn c512_l530_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c512_l530_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 531 +fn c513_l531_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c513_l531_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c513_l531_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 532 +fn c514_l532_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c514_l532_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c514_l532_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 533 +fn c515_l533_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c515_l533_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c515_l533_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 534 +fn c516_l534_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c516_l534_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c516_l534_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 535 +fn c517_l535_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c517_l535_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c517_l535_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 536 +fn c518_l536_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c518_l536_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c518_l536_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 537 +fn c519_l537_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c519_l537_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c519_l537_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 538 +fn c520_l538_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c520_l538_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c520_l538_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 539 +fn c521_l539_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c521_l539_action_invoke"); + let result = instance.call("sub", &[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 540 +fn c522_l540_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c522_l540_action_invoke"); + let result = instance.call("sub", &[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 541 +fn c523_l541_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c523_l541_action_invoke"); + let result = instance.call("sub", &[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 542 +fn c524_l542_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c524_l542_action_invoke"); + let result = instance.call("sub", &[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 543 +fn c525_l543_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c525_l543_action_invoke"); + let result = instance.call("sub", &[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 544 +fn c526_l544_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c526_l544_action_invoke"); + let result = instance.call("sub", &[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 545 +fn c527_l545_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c527_l545_action_invoke"); + let result = instance.call("sub", &[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 546 +fn c528_l546_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c528_l546_action_invoke"); + let result = instance.call("sub", &[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 547 +fn c529_l547_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c529_l547_action_invoke"); + let result = instance.call("sub", &[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 548 +fn c530_l548_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c530_l548_action_invoke"); + let result = instance.call("sub", &[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 549 +fn c531_l549_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c531_l549_action_invoke"); + let result = instance.call("sub", &[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 550 +fn c532_l550_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c532_l550_action_invoke"); + let result = instance.call("sub", &[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 551 +fn c533_l551_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c533_l551_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 552 +fn c534_l552_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c534_l552_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 553 +fn c535_l553_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c535_l553_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 554 +fn c536_l554_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c536_l554_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.5f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 555 +fn c537_l555_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c537_l555_action_invoke"); + let result = instance.call("sub", &[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 556 +fn c538_l556_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c538_l556_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.5f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 557 +fn c539_l557_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c539_l557_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.5f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 558 +fn c540_l558_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c540_l558_action_invoke"); + let result = instance.call("sub", &[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 559 +fn c541_l559_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c541_l559_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.5f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((5.7831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 560 +fn c542_l560_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c542_l560_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.5f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6.7831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 561 +fn c543_l561_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c543_l561_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.5f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((6.7831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 562 +fn c544_l562_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c544_l562_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.5f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-5.7831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 563 +fn c545_l563_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c545_l563_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.5f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 564 +fn c546_l564_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c546_l564_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.5f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 565 +fn c547_l565_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c547_l565_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.5f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 566 +fn c548_l566_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c548_l566_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.5f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 567 +fn c549_l567_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c549_l567_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 568 +fn c550_l568_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c550_l568_action_invoke"); + let result = instance.call("sub", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 569 +fn c551_l569_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c551_l569_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 570 +fn c552_l570_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c552_l570_action_invoke"); + let result = instance.call("sub", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 571 +fn c553_l571_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c553_l571_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c553_l571_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 572 +fn c554_l572_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c554_l572_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c554_l572_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 573 +fn c555_l573_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c555_l573_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c555_l573_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 574 +fn c556_l574_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c556_l574_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c556_l574_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 575 +fn c557_l575_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c557_l575_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c557_l575_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 576 +fn c558_l576_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c558_l576_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c558_l576_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 577 +fn c559_l577_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c559_l577_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c559_l577_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 578 +fn c560_l578_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c560_l578_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c560_l578_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 579 +fn c561_l579_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c561_l579_action_invoke"); + let result = instance.call("sub", &[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 580 +fn c562_l580_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c562_l580_action_invoke"); + let result = instance.call("sub", &[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 581 +fn c563_l581_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c563_l581_action_invoke"); + let result = instance.call("sub", &[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 582 +fn c564_l582_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c564_l582_action_invoke"); + let result = instance.call("sub", &[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 583 +fn c565_l583_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c565_l583_action_invoke"); + let result = instance.call("sub", &[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 584 +fn c566_l584_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c566_l584_action_invoke"); + let result = instance.call("sub", &[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 585 +fn c567_l585_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c567_l585_action_invoke"); + let result = instance.call("sub", &[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 586 +fn c568_l586_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c568_l586_action_invoke"); + let result = instance.call("sub", &[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 587 +fn c569_l587_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c569_l587_action_invoke"); + let result = instance.call("sub", &[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 588 +fn c570_l588_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c570_l588_action_invoke"); + let result = instance.call("sub", &[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 589 +fn c571_l589_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c571_l589_action_invoke"); + let result = instance.call("sub", &[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 590 +fn c572_l590_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c572_l590_action_invoke"); + let result = instance.call("sub", &[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 591 +fn c573_l591_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c573_l591_action_invoke"); + let result = instance.call("sub", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 592 +fn c574_l592_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c574_l592_action_invoke"); + let result = instance.call("sub", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 593 +fn c575_l593_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c575_l593_action_invoke"); + let result = instance.call("sub", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 594 +fn c576_l594_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c576_l594_action_invoke"); + let result = instance.call("sub", &[Value::F32((1.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 595 +fn c577_l595_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c577_l595_action_invoke"); + let result = instance.call("sub", &[Value::F32((-1.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 596 +fn c578_l596_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c578_l596_action_invoke"); + let result = instance.call("sub", &[Value::F32((-1.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-2.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 597 +fn c579_l597_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c579_l597_action_invoke"); + let result = instance.call("sub", &[Value::F32((1.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((2.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 598 +fn c580_l598_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c580_l598_action_invoke"); + let result = instance.call("sub", &[Value::F32((1.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 599 +fn c581_l599_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c581_l599_action_invoke"); + let result = instance.call("sub", &[Value::F32((-1.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((5.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 600 +fn c582_l600_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c582_l600_action_invoke"); + let result = instance.call("sub", &[Value::F32((-1.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-7.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 601 +fn c583_l601_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c583_l601_action_invoke"); + let result = instance.call("sub", &[Value::F32((1.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((7.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 602 +fn c584_l602_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c584_l602_action_invoke"); + let result = instance.call("sub", &[Value::F32((1.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-5.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 603 +fn c585_l603_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c585_l603_action_invoke"); + let result = instance.call("sub", &[Value::F32((-1.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 604 +fn c586_l604_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c586_l604_action_invoke"); + let result = instance.call("sub", &[Value::F32((-1.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 605 +fn c587_l605_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c587_l605_action_invoke"); + let result = instance.call("sub", &[Value::F32((1.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 606 +fn c588_l606_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c588_l606_action_invoke"); + let result = instance.call("sub", &[Value::F32((1.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 607 +fn c589_l607_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c589_l607_action_invoke"); + let result = instance.call("sub", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 608 +fn c590_l608_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c590_l608_action_invoke"); + let result = instance.call("sub", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 609 +fn c591_l609_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c591_l609_action_invoke"); + let result = instance.call("sub", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 610 +fn c592_l610_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c592_l610_action_invoke"); + let result = instance.call("sub", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 611 +fn c593_l611_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c593_l611_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c593_l611_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 612 +fn c594_l612_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c594_l612_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c594_l612_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 613 +fn c595_l613_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c595_l613_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c595_l613_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 614 +fn c596_l614_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c596_l614_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c596_l614_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 615 +fn c597_l615_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c597_l615_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c597_l615_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 616 +fn c598_l616_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c598_l616_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c598_l616_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 617 +fn c599_l617_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c599_l617_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c599_l617_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 618 +fn c600_l618_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c600_l618_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c600_l618_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 619 +fn c601_l619_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c601_l619_action_invoke"); + let result = instance.call("sub", &[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 620 +fn c602_l620_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c602_l620_action_invoke"); + let result = instance.call("sub", &[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 621 +fn c603_l621_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c603_l621_action_invoke"); + let result = instance.call("sub", &[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 622 +fn c604_l622_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c604_l622_action_invoke"); + let result = instance.call("sub", &[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 623 +fn c605_l623_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c605_l623_action_invoke"); + let result = instance.call("sub", &[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 624 +fn c606_l624_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c606_l624_action_invoke"); + let result = instance.call("sub", &[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 625 +fn c607_l625_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c607_l625_action_invoke"); + let result = instance.call("sub", &[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 626 +fn c608_l626_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c608_l626_action_invoke"); + let result = instance.call("sub", &[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 627 +fn c609_l627_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c609_l627_action_invoke"); + let result = instance.call("sub", &[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 628 +fn c610_l628_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c610_l628_action_invoke"); + let result = instance.call("sub", &[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 629 +fn c611_l629_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c611_l629_action_invoke"); + let result = instance.call("sub", &[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 630 +fn c612_l630_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c612_l630_action_invoke"); + let result = instance.call("sub", &[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 631 +fn c613_l631_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c613_l631_action_invoke"); + let result = instance.call("sub", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-5.7831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 632 +fn c614_l632_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c614_l632_action_invoke"); + let result = instance.call("sub", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6.7831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 633 +fn c615_l633_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c615_l633_action_invoke"); + let result = instance.call("sub", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((6.7831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 634 +fn c616_l634_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c616_l634_action_invoke"); + let result = instance.call("sub", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((5.7831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 635 +fn c617_l635_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c617_l635_action_invoke"); + let result = instance.call("sub", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-5.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 636 +fn c618_l636_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c618_l636_action_invoke"); + let result = instance.call("sub", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-7.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 637 +fn c619_l637_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c619_l637_action_invoke"); + let result = instance.call("sub", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((7.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 638 +fn c620_l638_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c620_l638_action_invoke"); + let result = instance.call("sub", &[Value::F32((6.2831855f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((5.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 639 +fn c621_l639_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c621_l639_action_invoke"); + let result = instance.call("sub", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 640 +fn c622_l640_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c622_l640_action_invoke"); + let result = instance.call("sub", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-12.566371f32).to_bits())))); + result.map(|_| ()) +} + +// Line 641 +fn c623_l641_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c623_l641_action_invoke"); + let result = instance.call("sub", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((12.566371f32).to_bits())))); + result.map(|_| ()) +} + +// Line 642 +fn c624_l642_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c624_l642_action_invoke"); + let result = instance.call("sub", &[Value::F32((6.2831855f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 643 +fn c625_l643_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c625_l643_action_invoke"); + let result = instance.call("sub", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 644 +fn c626_l644_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c626_l644_action_invoke"); + let result = instance.call("sub", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 645 +fn c627_l645_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c627_l645_action_invoke"); + let result = instance.call("sub", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 646 +fn c628_l646_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c628_l646_action_invoke"); + let result = instance.call("sub", &[Value::F32((6.2831855f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 647 +fn c629_l647_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c629_l647_action_invoke"); + let result = instance.call("sub", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 648 +fn c630_l648_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c630_l648_action_invoke"); + let result = instance.call("sub", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 649 +fn c631_l649_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c631_l649_action_invoke"); + let result = instance.call("sub", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 650 +fn c632_l650_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c632_l650_action_invoke"); + let result = instance.call("sub", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 651 +fn c633_l651_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c633_l651_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c633_l651_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 652 +fn c634_l652_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c634_l652_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c634_l652_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 653 +fn c635_l653_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c635_l653_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c635_l653_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 654 +fn c636_l654_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c636_l654_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c636_l654_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 655 +fn c637_l655_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c637_l655_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c637_l655_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 656 +fn c638_l656_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c638_l656_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c638_l656_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 657 +fn c639_l657_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c639_l657_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c639_l657_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 658 +fn c640_l658_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c640_l658_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c640_l658_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 659 +fn c641_l659_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c641_l659_action_invoke"); + let result = instance.call("sub", &[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 660 +fn c642_l660_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c642_l660_action_invoke"); + let result = instance.call("sub", &[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 661 +fn c643_l661_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c643_l661_action_invoke"); + let result = instance.call("sub", &[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 662 +fn c644_l662_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c644_l662_action_invoke"); + let result = instance.call("sub", &[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 663 +fn c645_l663_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c645_l663_action_invoke"); + let result = instance.call("sub", &[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 664 +fn c646_l664_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c646_l664_action_invoke"); + let result = instance.call("sub", &[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 665 +fn c647_l665_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c647_l665_action_invoke"); + let result = instance.call("sub", &[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 666 +fn c648_l666_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c648_l666_action_invoke"); + let result = instance.call("sub", &[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 667 +fn c649_l667_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c649_l667_action_invoke"); + let result = instance.call("sub", &[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 668 +fn c650_l668_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c650_l668_action_invoke"); + let result = instance.call("sub", &[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 669 +fn c651_l669_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c651_l669_action_invoke"); + let result = instance.call("sub", &[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 670 +fn c652_l670_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c652_l670_action_invoke"); + let result = instance.call("sub", &[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 671 +fn c653_l671_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c653_l671_action_invoke"); + let result = instance.call("sub", &[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 672 +fn c654_l672_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c654_l672_action_invoke"); + let result = instance.call("sub", &[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 673 +fn c655_l673_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c655_l673_action_invoke"); + let result = instance.call("sub", &[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 674 +fn c656_l674_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c656_l674_action_invoke"); + let result = instance.call("sub", &[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 675 +fn c657_l675_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c657_l675_action_invoke"); + let result = instance.call("sub", &[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 676 +fn c658_l676_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c658_l676_action_invoke"); + let result = instance.call("sub", &[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 677 +fn c659_l677_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c659_l677_action_invoke"); + let result = instance.call("sub", &[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 678 +fn c660_l678_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c660_l678_action_invoke"); + let result = instance.call("sub", &[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 679 +fn c661_l679_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c661_l679_action_invoke"); + let result = instance.call("sub", &[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 680 +fn c662_l680_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c662_l680_action_invoke"); + let result = instance.call("sub", &[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 681 +fn c663_l681_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c663_l681_action_invoke"); + let result = instance.call("sub", &[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 682 +fn c664_l682_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c664_l682_action_invoke"); + let result = instance.call("sub", &[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 683 +fn c665_l683_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c665_l683_action_invoke"); + let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 684 +fn c666_l684_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c666_l684_action_invoke"); + let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 685 +fn c667_l685_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c667_l685_action_invoke"); + let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 686 +fn c668_l686_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c668_l686_action_invoke"); + let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 687 +fn c669_l687_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c669_l687_action_invoke"); + let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 688 +fn c670_l688_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c670_l688_action_invoke"); + let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 689 +fn c671_l689_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c671_l689_action_invoke"); + let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 690 +fn c672_l690_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c672_l690_action_invoke"); + let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 691 +fn c673_l691_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c673_l691_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c673_l691_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 692 +fn c674_l692_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c674_l692_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c674_l692_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 693 +fn c675_l693_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c675_l693_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c675_l693_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 694 +fn c676_l694_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c676_l694_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c676_l694_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 695 +fn c677_l695_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c677_l695_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c677_l695_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 696 +fn c678_l696_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c678_l696_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c678_l696_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 697 +fn c679_l697_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c679_l697_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c679_l697_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 698 +fn c680_l698_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c680_l698_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c680_l698_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 699 +fn c681_l699_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c681_l699_action_invoke"); + let result = instance.call("sub", &[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 700 +fn c682_l700_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c682_l700_action_invoke"); + let result = instance.call("sub", &[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 701 +fn c683_l701_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c683_l701_action_invoke"); + let result = instance.call("sub", &[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 702 +fn c684_l702_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c684_l702_action_invoke"); + let result = instance.call("sub", &[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 703 +fn c685_l703_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c685_l703_action_invoke"); + let result = instance.call("sub", &[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 704 +fn c686_l704_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c686_l704_action_invoke"); + let result = instance.call("sub", &[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 705 +fn c687_l705_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c687_l705_action_invoke"); + let result = instance.call("sub", &[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 706 +fn c688_l706_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c688_l706_action_invoke"); + let result = instance.call("sub", &[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 707 +fn c689_l707_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c689_l707_action_invoke"); + let result = instance.call("sub", &[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 708 +fn c690_l708_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c690_l708_action_invoke"); + let result = instance.call("sub", &[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 709 +fn c691_l709_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c691_l709_action_invoke"); + let result = instance.call("sub", &[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 710 +fn c692_l710_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c692_l710_action_invoke"); + let result = instance.call("sub", &[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 711 +fn c693_l711_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c693_l711_action_invoke"); + let result = instance.call("sub", &[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 712 +fn c694_l712_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c694_l712_action_invoke"); + let result = instance.call("sub", &[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 713 +fn c695_l713_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c695_l713_action_invoke"); + let result = instance.call("sub", &[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 714 +fn c696_l714_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c696_l714_action_invoke"); + let result = instance.call("sub", &[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 715 +fn c697_l715_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c697_l715_action_invoke"); + let result = instance.call("sub", &[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 716 +fn c698_l716_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c698_l716_action_invoke"); + let result = instance.call("sub", &[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 717 +fn c699_l717_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c699_l717_action_invoke"); + let result = instance.call("sub", &[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 718 +fn c700_l718_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c700_l718_action_invoke"); + let result = instance.call("sub", &[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 719 +fn c701_l719_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c701_l719_action_invoke"); + let result = instance.call("sub", &[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 720 +fn c702_l720_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c702_l720_action_invoke"); + let result = instance.call("sub", &[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 721 +fn c703_l721_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c703_l721_action_invoke"); + let result = instance.call("sub", &[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 722 +fn c704_l722_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c704_l722_action_invoke"); + let result = instance.call("sub", &[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 723 +fn c705_l723_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c705_l723_action_invoke"); + let result = instance.call("sub", &[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 724 +fn c706_l724_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c706_l724_action_invoke"); + let result = instance.call("sub", &[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 725 +fn c707_l725_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c707_l725_action_invoke"); + let result = instance.call("sub", &[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 726 +fn c708_l726_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c708_l726_action_invoke"); + let result = instance.call("sub", &[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 727 +fn c709_l727_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c709_l727_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c709_l727_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 728 +fn c710_l728_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c710_l728_action_invoke"); + let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 729 +fn c711_l729_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c711_l729_action_invoke"); + let result = instance.call("sub", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 730 +fn c712_l730_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c712_l730_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c712_l730_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 731 +fn c713_l731_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c713_l731_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c713_l731_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 732 +fn c714_l732_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c714_l732_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c714_l732_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 733 +fn c715_l733_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c715_l733_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c715_l733_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 734 +fn c716_l734_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c716_l734_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c716_l734_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 735 +fn c717_l735_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c717_l735_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c717_l735_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 736 +fn c718_l736_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c718_l736_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c718_l736_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 737 +fn c719_l737_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c719_l737_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c719_l737_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 738 +fn c720_l738_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c720_l738_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c720_l738_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 739 +fn c721_l739_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c721_l739_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c721_l739_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 740 +fn c722_l740_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c722_l740_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c722_l740_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 741 +fn c723_l741_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c723_l741_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c723_l741_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 742 +fn c724_l742_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c724_l742_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c724_l742_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 743 +fn c725_l743_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c725_l743_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c725_l743_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 744 +fn c726_l744_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c726_l744_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c726_l744_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 745 +fn c727_l745_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c727_l745_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c727_l745_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 746 +fn c728_l746_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c728_l746_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c728_l746_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 747 +fn c729_l747_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c729_l747_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c729_l747_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 748 +fn c730_l748_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c730_l748_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c730_l748_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 749 +fn c731_l749_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c731_l749_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c731_l749_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 750 +fn c732_l750_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c732_l750_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c732_l750_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 751 +fn c733_l751_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c733_l751_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c733_l751_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 752 +fn c734_l752_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c734_l752_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c734_l752_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 753 +fn c735_l753_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c735_l753_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c735_l753_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 754 +fn c736_l754_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c736_l754_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c736_l754_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 755 +fn c737_l755_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c737_l755_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c737_l755_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 756 +fn c738_l756_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c738_l756_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c738_l756_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 757 +fn c739_l757_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c739_l757_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c739_l757_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 758 +fn c740_l758_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c740_l758_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c740_l758_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 759 +fn c741_l759_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c741_l759_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c741_l759_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 760 +fn c742_l760_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c742_l760_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c742_l760_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 761 +fn c743_l761_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c743_l761_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c743_l761_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 762 +fn c744_l762_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c744_l762_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c744_l762_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 763 +fn c745_l763_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c745_l763_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c745_l763_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 764 +fn c746_l764_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c746_l764_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c746_l764_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 765 +fn c747_l765_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c747_l765_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c747_l765_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 766 +fn c748_l766_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c748_l766_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c748_l766_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 767 +fn c749_l767_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c749_l767_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c749_l767_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 768 +fn c750_l768_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c750_l768_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c750_l768_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 769 +fn c751_l769_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c751_l769_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c751_l769_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 770 +fn c752_l770_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c752_l770_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c752_l770_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 771 +fn c753_l771_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c753_l771_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c753_l771_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 772 +fn c754_l772_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c754_l772_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c754_l772_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 773 +fn c755_l773_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c755_l773_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c755_l773_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 774 +fn c756_l774_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c756_l774_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c756_l774_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 775 +fn c757_l775_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c757_l775_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c757_l775_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 776 +fn c758_l776_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c758_l776_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c758_l776_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 777 +fn c759_l777_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c759_l777_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c759_l777_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 778 +fn c760_l778_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c760_l778_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c760_l778_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 779 +fn c761_l779_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c761_l779_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c761_l779_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 780 +fn c762_l780_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c762_l780_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c762_l780_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 781 +fn c763_l781_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c763_l781_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c763_l781_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 782 +fn c764_l782_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c764_l782_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c764_l782_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 783 +fn c765_l783_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c765_l783_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c765_l783_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 784 +fn c766_l784_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c766_l784_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c766_l784_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 785 +fn c767_l785_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c767_l785_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c767_l785_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 786 +fn c768_l786_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c768_l786_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c768_l786_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 787 +fn c769_l787_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c769_l787_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c769_l787_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 788 +fn c770_l788_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c770_l788_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c770_l788_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 789 +fn c771_l789_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c771_l789_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c771_l789_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 790 +fn c772_l790_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c772_l790_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c772_l790_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 791 +fn c773_l791_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c773_l791_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c773_l791_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 792 +fn c774_l792_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c774_l792_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c774_l792_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 793 +fn c775_l793_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c775_l793_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c775_l793_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 794 +fn c776_l794_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c776_l794_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c776_l794_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 795 +fn c777_l795_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c777_l795_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c777_l795_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 796 +fn c778_l796_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c778_l796_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c778_l796_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 797 +fn c779_l797_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c779_l797_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c779_l797_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 798 +fn c780_l798_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c780_l798_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c780_l798_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 799 +fn c781_l799_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c781_l799_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c781_l799_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 800 +fn c782_l800_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c782_l800_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c782_l800_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 801 +fn c783_l801_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c783_l801_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c783_l801_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 802 +fn c784_l802_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c784_l802_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c784_l802_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 803 +fn c785_l803_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c785_l803_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c785_l803_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 804 +fn c786_l804_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c786_l804_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c786_l804_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 805 +fn c787_l805_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c787_l805_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c787_l805_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 806 +fn c788_l806_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c788_l806_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c788_l806_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 807 +fn c789_l807_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c789_l807_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c789_l807_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 808 +fn c790_l808_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c790_l808_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c790_l808_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 809 +fn c791_l809_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c791_l809_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c791_l809_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 810 +fn c792_l810_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c792_l810_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c792_l810_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 811 +fn c793_l811_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c793_l811_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c793_l811_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 812 +fn c794_l812_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c794_l812_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c794_l812_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 813 +fn c795_l813_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c795_l813_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c795_l813_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 814 +fn c796_l814_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c796_l814_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c796_l814_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 815 +fn c797_l815_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c797_l815_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c797_l815_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 816 +fn c798_l816_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c798_l816_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c798_l816_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 817 +fn c799_l817_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c799_l817_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c799_l817_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 818 +fn c800_l818_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c800_l818_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c800_l818_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 819 +fn c801_l819_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c801_l819_action_invoke"); + let result = instance.call("mul", &[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 820 +fn c802_l820_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c802_l820_action_invoke"); + let result = instance.call("mul", &[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 821 +fn c803_l821_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c803_l821_action_invoke"); + let result = instance.call("mul", &[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 822 +fn c804_l822_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c804_l822_action_invoke"); + let result = instance.call("mul", &[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 823 +fn c805_l823_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c805_l823_action_invoke"); + let result = instance.call("mul", &[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 824 +fn c806_l824_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c806_l824_action_invoke"); + let result = instance.call("mul", &[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 825 +fn c807_l825_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c807_l825_action_invoke"); + let result = instance.call("mul", &[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 826 +fn c808_l826_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c808_l826_action_invoke"); + let result = instance.call("mul", &[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 827 +fn c809_l827_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c809_l827_action_invoke"); + let result = instance.call("mul", &[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 828 +fn c810_l828_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c810_l828_action_invoke"); + let result = instance.call("mul", &[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 829 +fn c811_l829_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c811_l829_action_invoke"); + let result = instance.call("mul", &[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 830 +fn c812_l830_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c812_l830_action_invoke"); + let result = instance.call("mul", &[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 831 +fn c813_l831_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c813_l831_action_invoke"); + let result = instance.call("mul", &[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 832 +fn c814_l832_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c814_l832_action_invoke"); + let result = instance.call("mul", &[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 833 +fn c815_l833_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c815_l833_action_invoke"); + let result = instance.call("mul", &[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 834 +fn c816_l834_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c816_l834_action_invoke"); + let result = instance.call("mul", &[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 835 +fn c817_l835_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c817_l835_action_invoke"); + let result = instance.call("mul", &[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 836 +fn c818_l836_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c818_l836_action_invoke"); + let result = instance.call("mul", &[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 837 +fn c819_l837_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c819_l837_action_invoke"); + let result = instance.call("mul", &[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 838 +fn c820_l838_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c820_l838_action_invoke"); + let result = instance.call("mul", &[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 839 +fn c821_l839_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c821_l839_action_invoke"); + let result = instance.call("mul", &[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 840 +fn c822_l840_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c822_l840_action_invoke"); + let result = instance.call("mul", &[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 841 +fn c823_l841_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c823_l841_action_invoke"); + let result = instance.call("mul", &[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 842 +fn c824_l842_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c824_l842_action_invoke"); + let result = instance.call("mul", &[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 843 +fn c825_l843_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c825_l843_action_invoke"); + let result = instance.call("mul", &[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 844 +fn c826_l844_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c826_l844_action_invoke"); + let result = instance.call("mul", &[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 845 +fn c827_l845_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c827_l845_action_invoke"); + let result = instance.call("mul", &[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 846 +fn c828_l846_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c828_l846_action_invoke"); + let result = instance.call("mul", &[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 847 +fn c829_l847_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c829_l847_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c829_l847_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 848 +fn c830_l848_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c830_l848_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c830_l848_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 849 +fn c831_l849_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c831_l849_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c831_l849_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 850 +fn c832_l850_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c832_l850_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c832_l850_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 851 +fn c833_l851_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c833_l851_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c833_l851_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 852 +fn c834_l852_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c834_l852_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c834_l852_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 853 +fn c835_l853_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c835_l853_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c835_l853_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 854 +fn c836_l854_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c836_l854_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c836_l854_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 855 +fn c837_l855_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c837_l855_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c837_l855_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 856 +fn c838_l856_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c838_l856_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c838_l856_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 857 +fn c839_l857_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c839_l857_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c839_l857_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 858 +fn c840_l858_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c840_l858_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c840_l858_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 859 +fn c841_l859_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c841_l859_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 860 +fn c842_l860_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c842_l860_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 861 +fn c843_l861_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c843_l861_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 862 +fn c844_l862_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c844_l862_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 863 +fn c845_l863_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c845_l863_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 864 +fn c846_l864_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c846_l864_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 865 +fn c847_l865_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c847_l865_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 866 +fn c848_l866_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c848_l866_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 867 +fn c849_l867_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c849_l867_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 868 +fn c850_l868_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c850_l868_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 869 +fn c851_l869_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c851_l869_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 870 +fn c852_l870_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c852_l870_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 871 +fn c853_l871_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c853_l871_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 872 +fn c854_l872_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c854_l872_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 873 +fn c855_l873_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c855_l873_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 874 +fn c856_l874_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c856_l874_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 875 +fn c857_l875_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c857_l875_action_invoke"); + let result = instance.call("mul", &[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 876 +fn c858_l876_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c858_l876_action_invoke"); + let result = instance.call("mul", &[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 877 +fn c859_l877_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c859_l877_action_invoke"); + let result = instance.call("mul", &[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 878 +fn c860_l878_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c860_l878_action_invoke"); + let result = instance.call("mul", &[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 879 +fn c861_l879_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c861_l879_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000008f32).to_bits())))); + result.map(|_| ()) +} + +// Line 880 +fn c862_l880_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c862_l880_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000008f32).to_bits())))); + result.map(|_| ()) +} + +// Line 881 +fn c863_l881_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c863_l881_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000008f32).to_bits())))); + result.map(|_| ()) +} + +// Line 882 +fn c864_l882_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c864_l882_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000008f32).to_bits())))); + result.map(|_| ()) +} + +// Line 883 +fn c865_l883_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c865_l883_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.00000047683713f32).to_bits())))); + result.map(|_| ()) +} + +// Line 884 +fn c866_l884_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c866_l884_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.00000047683713f32).to_bits())))); + result.map(|_| ()) +} + +// Line 885 +fn c867_l885_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c867_l885_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.00000047683713f32).to_bits())))); + result.map(|_| ()) +} + +// Line 886 +fn c868_l886_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c868_l886_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.00000047683713f32).to_bits())))); + result.map(|_| ()) +} + +// Line 887 +fn c869_l887_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c869_l887_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 888 +fn c870_l888_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c870_l888_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 889 +fn c871_l889_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c871_l889_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 890 +fn c872_l890_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c872_l890_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 891 +fn c873_l891_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c873_l891_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c873_l891_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 892 +fn c874_l892_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c874_l892_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c874_l892_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 893 +fn c875_l893_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c875_l893_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c875_l893_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 894 +fn c876_l894_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c876_l894_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c876_l894_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 895 +fn c877_l895_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c877_l895_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c877_l895_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 896 +fn c878_l896_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c878_l896_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c878_l896_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 897 +fn c879_l897_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c879_l897_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c879_l897_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 898 +fn c880_l898_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c880_l898_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c880_l898_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 899 +fn c881_l899_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c881_l899_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 900 +fn c882_l900_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c882_l900_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 901 +fn c883_l901_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c883_l901_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 902 +fn c884_l902_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c884_l902_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 903 +fn c885_l903_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c885_l903_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 904 +fn c886_l904_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c886_l904_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 905 +fn c887_l905_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c887_l905_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 906 +fn c888_l906_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c888_l906_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 907 +fn c889_l907_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c889_l907_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 908 +fn c890_l908_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c890_l908_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 909 +fn c891_l909_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c891_l909_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 910 +fn c892_l910_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c892_l910_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 911 +fn c893_l911_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c893_l911_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000005877472f32).to_bits())))); + result.map(|_| ()) +} + +// Line 912 +fn c894_l912_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c894_l912_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000005877472f32).to_bits())))); + result.map(|_| ()) +} + +// Line 913 +fn c895_l913_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c895_l913_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000005877472f32).to_bits())))); + result.map(|_| ()) +} + +// Line 914 +fn c896_l914_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c896_l914_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000005877472f32).to_bits())))); + result.map(|_| ()) +} + +// Line 915 +fn c897_l915_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c897_l915_action_invoke"); + let result = instance.call("mul", &[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 916 +fn c898_l916_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c898_l916_action_invoke"); + let result = instance.call("mul", &[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 917 +fn c899_l917_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c899_l917_action_invoke"); + let result = instance.call("mul", &[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 918 +fn c900_l918_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c900_l918_action_invoke"); + let result = instance.call("mul", &[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 919 +fn c901_l919_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c901_l919_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000000000000000000000007385849f32).to_bits())))); + result.map(|_| ()) +} + +// Line 920 +fn c902_l920_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c902_l920_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000000000000000000000007385849f32).to_bits())))); + result.map(|_| ()) +} + +// Line 921 +fn c903_l921_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c903_l921_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000000000000000000000007385849f32).to_bits())))); + result.map(|_| ()) +} + +// Line 922 +fn c904_l922_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c904_l922_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000000000000000000000007385849f32).to_bits())))); + result.map(|_| ()) +} + +// Line 923 +fn c905_l923_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c905_l923_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((3.9999998f32).to_bits())))); + result.map(|_| ()) +} + +// Line 924 +fn c906_l924_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c906_l924_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-3.9999998f32).to_bits())))); + result.map(|_| ()) +} + +// Line 925 +fn c907_l925_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c907_l925_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-3.9999998f32).to_bits())))); + result.map(|_| ()) +} + +// Line 926 +fn c908_l926_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c908_l926_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((3.9999998f32).to_bits())))); + result.map(|_| ()) +} + +// Line 927 +fn c909_l927_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c909_l927_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 928 +fn c910_l928_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c910_l928_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 929 +fn c911_l929_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c911_l929_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 930 +fn c912_l930_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c912_l930_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 931 +fn c913_l931_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c913_l931_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c913_l931_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 932 +fn c914_l932_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c914_l932_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c914_l932_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 933 +fn c915_l933_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c915_l933_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c915_l933_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 934 +fn c916_l934_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c916_l934_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c916_l934_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 935 +fn c917_l935_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c917_l935_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c917_l935_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 936 +fn c918_l936_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c918_l936_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c918_l936_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 937 +fn c919_l937_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c919_l937_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c919_l937_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 938 +fn c920_l938_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c920_l938_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c920_l938_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 939 +fn c921_l939_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c921_l939_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 940 +fn c922_l940_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c922_l940_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 941 +fn c923_l941_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c923_l941_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 942 +fn c924_l942_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c924_l942_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.5f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 943 +fn c925_l943_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c925_l943_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 944 +fn c926_l944_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c926_l944_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 945 +fn c927_l945_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c927_l945_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 946 +fn c928_l946_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c928_l946_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 947 +fn c929_l947_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c929_l947_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000005877472f32).to_bits())))); + result.map(|_| ()) +} + +// Line 948 +fn c930_l948_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c930_l948_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000005877472f32).to_bits())))); + result.map(|_| ()) +} + +// Line 949 +fn c931_l949_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c931_l949_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000005877472f32).to_bits())))); + result.map(|_| ()) +} + +// Line 950 +fn c932_l950_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c932_l950_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000005877472f32).to_bits())))); + result.map(|_| ()) +} + +// Line 951 +fn c933_l951_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c933_l951_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.25f32).to_bits())))); + result.map(|_| ()) +} + +// Line 952 +fn c934_l952_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c934_l952_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.25f32).to_bits())))); + result.map(|_| ()) +} + +// Line 953 +fn c935_l953_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c935_l953_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.25f32).to_bits())))); + result.map(|_| ()) +} + +// Line 954 +fn c936_l954_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c936_l954_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.5f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.25f32).to_bits())))); + result.map(|_| ()) +} + +// Line 955 +fn c937_l955_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c937_l955_action_invoke"); + let result = instance.call("mul", &[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 956 +fn c938_l956_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c938_l956_action_invoke"); + let result = instance.call("mul", &[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 957 +fn c939_l957_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c939_l957_action_invoke"); + let result = instance.call("mul", &[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 958 +fn c940_l958_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c940_l958_action_invoke"); + let result = instance.call("mul", &[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 959 +fn c941_l959_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c941_l959_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.5f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((3.1415927f32).to_bits())))); + result.map(|_| ()) +} + +// Line 960 +fn c942_l960_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c942_l960_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.5f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-3.1415927f32).to_bits())))); + result.map(|_| ()) +} + +// Line 961 +fn c943_l961_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c943_l961_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.5f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-3.1415927f32).to_bits())))); + result.map(|_| ()) +} + +// Line 962 +fn c944_l962_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c944_l962_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.5f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((3.1415927f32).to_bits())))); + result.map(|_| ()) +} + +// Line 963 +fn c945_l963_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c945_l963_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.5f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((170141170000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 964 +fn c946_l964_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c946_l964_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.5f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-170141170000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 965 +fn c947_l965_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c947_l965_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.5f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-170141170000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 966 +fn c948_l966_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c948_l966_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.5f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((170141170000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 967 +fn c949_l967_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c949_l967_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 968 +fn c950_l968_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c950_l968_action_invoke"); + let result = instance.call("mul", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 969 +fn c951_l969_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c951_l969_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 970 +fn c952_l970_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c952_l970_action_invoke"); + let result = instance.call("mul", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 971 +fn c953_l971_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c953_l971_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c953_l971_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 972 +fn c954_l972_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c954_l972_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c954_l972_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 973 +fn c955_l973_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c955_l973_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c955_l973_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 974 +fn c956_l974_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c956_l974_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c956_l974_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 975 +fn c957_l975_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c957_l975_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c957_l975_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 976 +fn c958_l976_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c958_l976_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c958_l976_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 977 +fn c959_l977_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c959_l977_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c959_l977_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 978 +fn c960_l978_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c960_l978_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c960_l978_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 979 +fn c961_l979_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c961_l979_action_invoke"); + let result = instance.call("mul", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 980 +fn c962_l980_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c962_l980_action_invoke"); + let result = instance.call("mul", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 981 +fn c963_l981_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c963_l981_action_invoke"); + let result = instance.call("mul", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 982 +fn c964_l982_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c964_l982_action_invoke"); + let result = instance.call("mul", &[Value::F32((1.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 983 +fn c965_l983_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c965_l983_action_invoke"); + let result = instance.call("mul", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 984 +fn c966_l984_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c966_l984_action_invoke"); + let result = instance.call("mul", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 985 +fn c967_l985_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c967_l985_action_invoke"); + let result = instance.call("mul", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 986 +fn c968_l986_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c968_l986_action_invoke"); + let result = instance.call("mul", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 987 +fn c969_l987_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c969_l987_action_invoke"); + let result = instance.call("mul", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 988 +fn c970_l988_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c970_l988_action_invoke"); + let result = instance.call("mul", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 989 +fn c971_l989_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c971_l989_action_invoke"); + let result = instance.call("mul", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 990 +fn c972_l990_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c972_l990_action_invoke"); + let result = instance.call("mul", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 991 +fn c973_l991_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c973_l991_action_invoke"); + let result = instance.call("mul", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 992 +fn c974_l992_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c974_l992_action_invoke"); + let result = instance.call("mul", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 993 +fn c975_l993_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c975_l993_action_invoke"); + let result = instance.call("mul", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 994 +fn c976_l994_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c976_l994_action_invoke"); + let result = instance.call("mul", &[Value::F32((1.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 995 +fn c977_l995_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c977_l995_action_invoke"); + let result = instance.call("mul", &[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 996 +fn c978_l996_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c978_l996_action_invoke"); + let result = instance.call("mul", &[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 997 +fn c979_l997_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c979_l997_action_invoke"); + let result = instance.call("mul", &[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 998 +fn c980_l998_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c980_l998_action_invoke"); + let result = instance.call("mul", &[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 999 +fn c981_l999_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c981_l999_action_invoke"); + let result = instance.call("mul", &[Value::F32((-1.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1000 +fn c982_l1000_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c982_l1000_action_invoke"); + let result = instance.call("mul", &[Value::F32((-1.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1001 +fn c983_l1001_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c983_l1001_action_invoke"); + let result = instance.call("mul", &[Value::F32((1.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1002 +fn c984_l1002_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c984_l1002_action_invoke"); + let result = instance.call("mul", &[Value::F32((1.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1003 +fn c985_l1003_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c985_l1003_action_invoke"); + let result = instance.call("mul", &[Value::F32((-1.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1004 +fn c986_l1004_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c986_l1004_action_invoke"); + let result = instance.call("mul", &[Value::F32((-1.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1005 +fn c987_l1005_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c987_l1005_action_invoke"); + let result = instance.call("mul", &[Value::F32((1.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1006 +fn c988_l1006_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c988_l1006_action_invoke"); + let result = instance.call("mul", &[Value::F32((1.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1007 +fn c989_l1007_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c989_l1007_action_invoke"); + let result = instance.call("mul", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1008 +fn c990_l1008_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c990_l1008_action_invoke"); + let result = instance.call("mul", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1009 +fn c991_l1009_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c991_l1009_action_invoke"); + let result = instance.call("mul", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1010 +fn c992_l1010_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c992_l1010_action_invoke"); + let result = instance.call("mul", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1011 +fn c993_l1011_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c993_l1011_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c993_l1011_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1012 +fn c994_l1012_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c994_l1012_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c994_l1012_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1013 +fn c995_l1013_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c995_l1013_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c995_l1013_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1014 +fn c996_l1014_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c996_l1014_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c996_l1014_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1015 +fn c997_l1015_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c997_l1015_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c997_l1015_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1016 +fn c998_l1016_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c998_l1016_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c998_l1016_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1017 +fn c999_l1017_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c999_l1017_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c999_l1017_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1018 +fn c1000_l1018_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1000_l1018_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1000_l1018_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1019 +fn c1001_l1019_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1001_l1019_action_invoke"); + let result = instance.call("mul", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1020 +fn c1002_l1020_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1002_l1020_action_invoke"); + let result = instance.call("mul", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1021 +fn c1003_l1021_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1003_l1021_action_invoke"); + let result = instance.call("mul", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1022 +fn c1004_l1022_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1004_l1022_action_invoke"); + let result = instance.call("mul", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1023 +fn c1005_l1023_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1005_l1023_action_invoke"); + let result = instance.call("mul", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000008f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1024 +fn c1006_l1024_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1006_l1024_action_invoke"); + let result = instance.call("mul", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000008f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1025 +fn c1007_l1025_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1007_l1025_action_invoke"); + let result = instance.call("mul", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000008f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1026 +fn c1008_l1026_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1008_l1026_action_invoke"); + let result = instance.call("mul", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000008f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1027 +fn c1009_l1027_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1009_l1027_action_invoke"); + let result = instance.call("mul", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000000000000000000000007385849f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1028 +fn c1010_l1028_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1010_l1028_action_invoke"); + let result = instance.call("mul", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000000000000000000000007385849f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1029 +fn c1011_l1029_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1011_l1029_action_invoke"); + let result = instance.call("mul", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000000000000000000000007385849f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1030 +fn c1012_l1030_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1012_l1030_action_invoke"); + let result = instance.call("mul", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000000000000000000000007385849f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1031 +fn c1013_l1031_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1013_l1031_action_invoke"); + let result = instance.call("mul", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((3.1415927f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1032 +fn c1014_l1032_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1014_l1032_action_invoke"); + let result = instance.call("mul", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-3.1415927f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1033 +fn c1015_l1033_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1015_l1033_action_invoke"); + let result = instance.call("mul", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-3.1415927f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1034 +fn c1016_l1034_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1016_l1034_action_invoke"); + let result = instance.call("mul", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((3.1415927f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1035 +fn c1017_l1035_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1017_l1035_action_invoke"); + let result = instance.call("mul", &[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 1036 +fn c1018_l1036_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1018_l1036_action_invoke"); + let result = instance.call("mul", &[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 1037 +fn c1019_l1037_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1019_l1037_action_invoke"); + let result = instance.call("mul", &[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 1038 +fn c1020_l1038_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1020_l1038_action_invoke"); + let result = instance.call("mul", &[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 1039 +fn c1021_l1039_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1021_l1039_action_invoke"); + let result = instance.call("mul", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((39.47842f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1040 +fn c1022_l1040_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1022_l1040_action_invoke"); + let result = instance.call("mul", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-39.47842f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1041 +fn c1023_l1041_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1023_l1041_action_invoke"); + let result = instance.call("mul", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-39.47842f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1042 +fn c1024_l1042_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1024_l1042_action_invoke"); + let result = instance.call("mul", &[Value::F32((6.2831855f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((39.47842f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1043 +fn c1025_l1043_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1025_l1043_action_invoke"); + let result = instance.call("mul", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1044 +fn c1026_l1044_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1026_l1044_action_invoke"); + let result = instance.call("mul", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1045 +fn c1027_l1045_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1027_l1045_action_invoke"); + let result = instance.call("mul", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1046 +fn c1028_l1046_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1028_l1046_action_invoke"); + let result = instance.call("mul", &[Value::F32((6.2831855f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1047 +fn c1029_l1047_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1029_l1047_action_invoke"); + let result = instance.call("mul", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1048 +fn c1030_l1048_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1030_l1048_action_invoke"); + let result = instance.call("mul", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1049 +fn c1031_l1049_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1031_l1049_action_invoke"); + let result = instance.call("mul", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1050 +fn c1032_l1050_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1032_l1050_action_invoke"); + let result = instance.call("mul", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1051 +fn c1033_l1051_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1033_l1051_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1033_l1051_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1052 +fn c1034_l1052_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1034_l1052_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1034_l1052_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1053 +fn c1035_l1053_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1035_l1053_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1035_l1053_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1054 +fn c1036_l1054_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1036_l1054_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1036_l1054_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1055 +fn c1037_l1055_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1037_l1055_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1037_l1055_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1056 +fn c1038_l1056_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1038_l1056_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1038_l1056_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1057 +fn c1039_l1057_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1039_l1057_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1039_l1057_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1058 +fn c1040_l1058_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1040_l1058_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1040_l1058_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1059 +fn c1041_l1059_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1041_l1059_action_invoke"); + let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1060 +fn c1042_l1060_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1042_l1060_action_invoke"); + let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1061 +fn c1043_l1061_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1043_l1061_action_invoke"); + let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1062 +fn c1044_l1062_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1044_l1062_action_invoke"); + let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1063 +fn c1045_l1063_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1045_l1063_action_invoke"); + let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.00000047683713f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1064 +fn c1046_l1064_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1046_l1064_action_invoke"); + let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.00000047683713f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1065 +fn c1047_l1065_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1047_l1065_action_invoke"); + let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.00000047683713f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1066 +fn c1048_l1066_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1048_l1066_action_invoke"); + let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.00000047683713f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1067 +fn c1049_l1067_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1049_l1067_action_invoke"); + let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((3.9999998f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1068 +fn c1050_l1068_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1050_l1068_action_invoke"); + let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-3.9999998f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1069 +fn c1051_l1069_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1051_l1069_action_invoke"); + let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-3.9999998f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1070 +fn c1052_l1070_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1052_l1070_action_invoke"); + let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((3.9999998f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1071 +fn c1053_l1071_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1053_l1071_action_invoke"); + let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((170141170000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1072 +fn c1054_l1072_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1054_l1072_action_invoke"); + let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-170141170000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1073 +fn c1055_l1073_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1055_l1073_action_invoke"); + let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-170141170000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1074 +fn c1056_l1074_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1056_l1074_action_invoke"); + let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((170141170000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1075 +fn c1057_l1075_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1057_l1075_action_invoke"); + let result = instance.call("mul", &[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 1076 +fn c1058_l1076_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1058_l1076_action_invoke"); + let result = instance.call("mul", &[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 1077 +fn c1059_l1077_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1059_l1077_action_invoke"); + let result = instance.call("mul", &[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 1078 +fn c1060_l1078_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1060_l1078_action_invoke"); + let result = instance.call("mul", &[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 1079 +fn c1061_l1079_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1061_l1079_action_invoke"); + let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1080 +fn c1062_l1080_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1062_l1080_action_invoke"); + let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1081 +fn c1063_l1081_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1063_l1081_action_invoke"); + let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1082 +fn c1064_l1082_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1064_l1082_action_invoke"); + let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1083 +fn c1065_l1083_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1065_l1083_action_invoke"); + let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1084 +fn c1066_l1084_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1066_l1084_action_invoke"); + let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1085 +fn c1067_l1085_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1067_l1085_action_invoke"); + let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1086 +fn c1068_l1086_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1068_l1086_action_invoke"); + let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1087 +fn c1069_l1087_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1069_l1087_action_invoke"); + let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1088 +fn c1070_l1088_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1070_l1088_action_invoke"); + let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1089 +fn c1071_l1089_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1071_l1089_action_invoke"); + let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1090 +fn c1072_l1090_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1072_l1090_action_invoke"); + let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1091 +fn c1073_l1091_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1073_l1091_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1073_l1091_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1092 +fn c1074_l1092_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1074_l1092_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1074_l1092_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1093 +fn c1075_l1093_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1075_l1093_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1075_l1093_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1094 +fn c1076_l1094_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1076_l1094_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1076_l1094_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1095 +fn c1077_l1095_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1077_l1095_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1077_l1095_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1096 +fn c1078_l1096_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1078_l1096_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1078_l1096_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1097 +fn c1079_l1097_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1079_l1097_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1079_l1097_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1098 +fn c1080_l1098_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1080_l1098_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1080_l1098_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1099 +fn c1081_l1099_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1081_l1099_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c1081_l1099_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1100 +fn c1082_l1100_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1082_l1100_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c1082_l1100_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1101 +fn c1083_l1101_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1083_l1101_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c1083_l1101_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1102 +fn c1084_l1102_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1084_l1102_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c1084_l1102_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1103 +fn c1085_l1103_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1085_l1103_action_invoke"); + let result = instance.call("mul", &[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 1104 +fn c1086_l1104_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1086_l1104_action_invoke"); + let result = instance.call("mul", &[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 1105 +fn c1087_l1105_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1087_l1105_action_invoke"); + let result = instance.call("mul", &[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 1106 +fn c1088_l1106_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1088_l1106_action_invoke"); + let result = instance.call("mul", &[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 1107 +fn c1089_l1107_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1089_l1107_action_invoke"); + let result = instance.call("mul", &[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 1108 +fn c1090_l1108_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1090_l1108_action_invoke"); + let result = instance.call("mul", &[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 1109 +fn c1091_l1109_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1091_l1109_action_invoke"); + let result = instance.call("mul", &[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 1110 +fn c1092_l1110_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1092_l1110_action_invoke"); + let result = instance.call("mul", &[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 1111 +fn c1093_l1111_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1093_l1111_action_invoke"); + let result = instance.call("mul", &[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 1112 +fn c1094_l1112_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1094_l1112_action_invoke"); + let result = instance.call("mul", &[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 1113 +fn c1095_l1113_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1095_l1113_action_invoke"); + let result = instance.call("mul", &[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 1114 +fn c1096_l1114_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1096_l1114_action_invoke"); + let result = instance.call("mul", &[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 1115 +fn c1097_l1115_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1097_l1115_action_invoke"); + let result = instance.call("mul", &[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 1116 +fn c1098_l1116_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1098_l1116_action_invoke"); + let result = instance.call("mul", &[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 1117 +fn c1099_l1117_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1099_l1117_action_invoke"); + let result = instance.call("mul", &[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 1118 +fn c1100_l1118_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1100_l1118_action_invoke"); + let result = instance.call("mul", &[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 1119 +fn c1101_l1119_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1101_l1119_action_invoke"); + let result = instance.call("mul", &[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 1120 +fn c1102_l1120_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1102_l1120_action_invoke"); + let result = instance.call("mul", &[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 1121 +fn c1103_l1121_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1103_l1121_action_invoke"); + let result = instance.call("mul", &[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 1122 +fn c1104_l1122_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1104_l1122_action_invoke"); + let result = instance.call("mul", &[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 1123 +fn c1105_l1123_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1105_l1123_action_invoke"); + let result = instance.call("mul", &[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 1124 +fn c1106_l1124_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1106_l1124_action_invoke"); + let result = instance.call("mul", &[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 1125 +fn c1107_l1125_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1107_l1125_action_invoke"); + let result = instance.call("mul", &[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 1126 +fn c1108_l1126_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1108_l1126_action_invoke"); + let result = instance.call("mul", &[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 1127 +fn c1109_l1127_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1109_l1127_action_invoke"); + let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1128 +fn c1110_l1128_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1110_l1128_action_invoke"); + let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1129 +fn c1111_l1129_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1111_l1129_action_invoke"); + let result = instance.call("mul", &[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 1130 +fn c1112_l1130_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1112_l1130_action_invoke"); + let result = instance.call("mul", &[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 1131 +fn c1113_l1131_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1113_l1131_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1113_l1131_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1132 +fn c1114_l1132_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1114_l1132_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1114_l1132_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1133 +fn c1115_l1133_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1115_l1133_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1115_l1133_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1134 +fn c1116_l1134_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1116_l1134_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1116_l1134_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1135 +fn c1117_l1135_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1117_l1135_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1117_l1135_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1136 +fn c1118_l1136_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1118_l1136_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1118_l1136_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1137 +fn c1119_l1137_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1119_l1137_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1119_l1137_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1138 +fn c1120_l1138_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1120_l1138_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1120_l1138_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1139 +fn c1121_l1139_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1121_l1139_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c1121_l1139_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1140 +fn c1122_l1140_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1122_l1140_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c1122_l1140_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1141 +fn c1123_l1141_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1123_l1141_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c1123_l1141_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1142 +fn c1124_l1142_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1124_l1142_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c1124_l1142_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1143 +fn c1125_l1143_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1125_l1143_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c1125_l1143_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1144 +fn c1126_l1144_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1126_l1144_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c1126_l1144_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1145 +fn c1127_l1145_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1127_l1145_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c1127_l1145_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1146 +fn c1128_l1146_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1128_l1146_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c1128_l1146_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1147 +fn c1129_l1147_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1129_l1147_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1129_l1147_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1148 +fn c1130_l1148_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1130_l1148_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1130_l1148_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1149 +fn c1131_l1149_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1131_l1149_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1131_l1149_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1150 +fn c1132_l1150_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1132_l1150_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1132_l1150_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1151 +fn c1133_l1151_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1133_l1151_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1133_l1151_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1152 +fn c1134_l1152_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1134_l1152_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1134_l1152_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1153 +fn c1135_l1153_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1135_l1153_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1135_l1153_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1154 +fn c1136_l1154_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1136_l1154_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1136_l1154_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1155 +fn c1137_l1155_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1137_l1155_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1137_l1155_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1156 +fn c1138_l1156_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1138_l1156_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1138_l1156_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1157 +fn c1139_l1157_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1139_l1157_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1139_l1157_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1158 +fn c1140_l1158_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1140_l1158_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1140_l1158_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1159 +fn c1141_l1159_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1141_l1159_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1141_l1159_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1160 +fn c1142_l1160_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1142_l1160_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1142_l1160_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1161 +fn c1143_l1161_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1143_l1161_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1143_l1161_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1162 +fn c1144_l1162_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1144_l1162_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1144_l1162_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1163 +fn c1145_l1163_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1145_l1163_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c1145_l1163_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1164 +fn c1146_l1164_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1146_l1164_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c1146_l1164_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1165 +fn c1147_l1165_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1147_l1165_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c1147_l1165_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1166 +fn c1148_l1166_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1148_l1166_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c1148_l1166_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1167 +fn c1149_l1167_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1149_l1167_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c1149_l1167_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1168 +fn c1150_l1168_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1150_l1168_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c1150_l1168_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1169 +fn c1151_l1169_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1151_l1169_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c1151_l1169_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1170 +fn c1152_l1170_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1152_l1170_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c1152_l1170_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1171 +fn c1153_l1171_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1153_l1171_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c1153_l1171_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1172 +fn c1154_l1172_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1154_l1172_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c1154_l1172_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1173 +fn c1155_l1173_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1155_l1173_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c1155_l1173_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1174 +fn c1156_l1174_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1156_l1174_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c1156_l1174_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1175 +fn c1157_l1175_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1157_l1175_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c1157_l1175_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1176 +fn c1158_l1176_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1158_l1176_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c1158_l1176_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1177 +fn c1159_l1177_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1159_l1177_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c1159_l1177_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1178 +fn c1160_l1178_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1160_l1178_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c1160_l1178_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1179 +fn c1161_l1179_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1161_l1179_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1161_l1179_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1180 +fn c1162_l1180_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1162_l1180_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1162_l1180_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1181 +fn c1163_l1181_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1163_l1181_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1163_l1181_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1182 +fn c1164_l1182_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1164_l1182_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1164_l1182_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1183 +fn c1165_l1183_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1165_l1183_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1165_l1183_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1184 +fn c1166_l1184_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1166_l1184_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1166_l1184_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1185 +fn c1167_l1185_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1167_l1185_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1167_l1185_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1186 +fn c1168_l1186_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1168_l1186_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1168_l1186_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1187 +fn c1169_l1187_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1169_l1187_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1169_l1187_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1188 +fn c1170_l1188_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1170_l1188_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1170_l1188_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1189 +fn c1171_l1189_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1171_l1189_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1171_l1189_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1190 +fn c1172_l1190_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1172_l1190_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1172_l1190_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1191 +fn c1173_l1191_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1173_l1191_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1173_l1191_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1192 +fn c1174_l1192_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1174_l1192_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1174_l1192_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1193 +fn c1175_l1193_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1175_l1193_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1175_l1193_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1194 +fn c1176_l1194_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1176_l1194_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1176_l1194_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1195 +fn c1177_l1195_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1177_l1195_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1177_l1195_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1196 +fn c1178_l1196_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1178_l1196_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1178_l1196_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1197 +fn c1179_l1197_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1179_l1197_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c1179_l1197_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1198 +fn c1180_l1198_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1180_l1198_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c1180_l1198_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1199 +fn c1181_l1199_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1181_l1199_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1181_l1199_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1200 +fn c1182_l1200_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1182_l1200_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1182_l1200_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1201 +fn c1183_l1201_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1183_l1201_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c1183_l1201_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1202 +fn c1184_l1202_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1184_l1202_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c1184_l1202_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1203 +fn c1185_l1203_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1185_l1203_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1185_l1203_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1204 +fn c1186_l1204_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1186_l1204_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1186_l1204_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1205 +fn c1187_l1205_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1187_l1205_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1187_l1205_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1206 +fn c1188_l1206_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1188_l1206_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1188_l1206_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1207 +fn c1189_l1207_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1189_l1207_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1189_l1207_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1208 +fn c1190_l1208_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1190_l1208_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1190_l1208_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1209 +fn c1191_l1209_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1191_l1209_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1191_l1209_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1210 +fn c1192_l1210_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1192_l1210_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1192_l1210_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1211 +fn c1193_l1211_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1193_l1211_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1193_l1211_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1212 +fn c1194_l1212_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1194_l1212_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1194_l1212_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1213 +fn c1195_l1213_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1195_l1213_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1195_l1213_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1214 +fn c1196_l1214_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1196_l1214_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1196_l1214_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1215 +fn c1197_l1215_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1197_l1215_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1197_l1215_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1216 +fn c1198_l1216_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1198_l1216_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1198_l1216_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1217 +fn c1199_l1217_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1199_l1217_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1199_l1217_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1218 +fn c1200_l1218_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1200_l1218_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1200_l1218_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1219 +fn c1201_l1219_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1201_l1219_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c1201_l1219_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1220 +fn c1202_l1220_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1202_l1220_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c1202_l1220_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1221 +fn c1203_l1221_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1203_l1221_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c1203_l1221_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1222 +fn c1204_l1222_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1204_l1222_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32((0.0f32).to_bits()), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c1204_l1222_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1223 +fn c1205_l1223_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1205_l1223_action_invoke"); + let result = instance.call("div", &[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 1224 +fn c1206_l1224_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1206_l1224_action_invoke"); + let result = instance.call("div", &[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 1225 +fn c1207_l1225_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1207_l1225_action_invoke"); + let result = instance.call("div", &[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 1226 +fn c1208_l1226_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1208_l1226_action_invoke"); + let result = instance.call("div", &[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 1227 +fn c1209_l1227_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1209_l1227_action_invoke"); + let result = instance.call("div", &[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 1228 +fn c1210_l1228_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1210_l1228_action_invoke"); + let result = instance.call("div", &[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 1229 +fn c1211_l1229_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1211_l1229_action_invoke"); + let result = instance.call("div", &[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 1230 +fn c1212_l1230_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1212_l1230_action_invoke"); + let result = instance.call("div", &[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 1231 +fn c1213_l1231_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1213_l1231_action_invoke"); + let result = instance.call("div", &[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 1232 +fn c1214_l1232_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1214_l1232_action_invoke"); + let result = instance.call("div", &[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 1233 +fn c1215_l1233_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1215_l1233_action_invoke"); + let result = instance.call("div", &[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 1234 +fn c1216_l1234_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1216_l1234_action_invoke"); + let result = instance.call("div", &[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 1235 +fn c1217_l1235_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1217_l1235_action_invoke"); + let result = instance.call("div", &[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 1236 +fn c1218_l1236_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1218_l1236_action_invoke"); + let result = instance.call("div", &[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 1237 +fn c1219_l1237_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1219_l1237_action_invoke"); + let result = instance.call("div", &[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 1238 +fn c1220_l1238_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1220_l1238_action_invoke"); + let result = instance.call("div", &[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 1239 +fn c1221_l1239_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1221_l1239_action_invoke"); + let result = instance.call("div", &[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 1240 +fn c1222_l1240_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1222_l1240_action_invoke"); + let result = instance.call("div", &[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 1241 +fn c1223_l1241_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1223_l1241_action_invoke"); + let result = instance.call("div", &[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 1242 +fn c1224_l1242_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1224_l1242_action_invoke"); + let result = instance.call("div", &[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 1243 +fn c1225_l1243_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1225_l1243_action_invoke"); + let result = instance.call("div", &[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 1244 +fn c1226_l1244_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1226_l1244_action_invoke"); + let result = instance.call("div", &[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 1245 +fn c1227_l1245_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1227_l1245_action_invoke"); + let result = instance.call("div", &[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 1246 +fn c1228_l1246_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1228_l1246_action_invoke"); + let result = instance.call("div", &[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 1247 +fn c1229_l1247_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1229_l1247_action_invoke"); + let result = instance.call("div", &[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 1248 +fn c1230_l1248_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1230_l1248_action_invoke"); + let result = instance.call("div", &[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 1249 +fn c1231_l1249_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1231_l1249_action_invoke"); + let result = instance.call("div", &[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 1250 +fn c1232_l1250_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1232_l1250_action_invoke"); + let result = instance.call("div", &[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 1251 +fn c1233_l1251_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1233_l1251_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1233_l1251_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1252 +fn c1234_l1252_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1234_l1252_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1234_l1252_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1253 +fn c1235_l1253_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1235_l1253_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1235_l1253_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1254 +fn c1236_l1254_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1236_l1254_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1236_l1254_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1255 +fn c1237_l1255_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1237_l1255_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1237_l1255_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1256 +fn c1238_l1256_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1238_l1256_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1238_l1256_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1257 +fn c1239_l1257_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1239_l1257_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1239_l1257_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1258 +fn c1240_l1258_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1240_l1258_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1240_l1258_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1259 +fn c1241_l1259_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1241_l1259_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1260 +fn c1242_l1260_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1242_l1260_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1261 +fn c1243_l1261_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1243_l1261_action_invoke"); + let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1262 +fn c1244_l1262_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1244_l1262_action_invoke"); + let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1263 +fn c1245_l1263_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1245_l1263_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1264 +fn c1246_l1264_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1246_l1264_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1265 +fn c1247_l1265_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1247_l1265_action_invoke"); + let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1266 +fn c1248_l1266_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1248_l1266_action_invoke"); + let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1267 +fn c1249_l1267_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1249_l1267_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.00000011920929f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1268 +fn c1250_l1268_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1250_l1268_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.00000011920929f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1269 +fn c1251_l1269_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1251_l1269_action_invoke"); + let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.00000011920929f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1270 +fn c1252_l1270_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1252_l1270_action_invoke"); + let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.00000011920929f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1271 +fn c1253_l1271_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1253_l1271_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000003f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1272 +fn c1254_l1272_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1254_l1272_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000003f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1273 +fn c1255_l1273_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1255_l1273_action_invoke"); + let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000003f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1274 +fn c1256_l1274_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1256_l1274_action_invoke"); + let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000003f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1275 +fn c1257_l1275_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1257_l1275_action_invoke"); + let result = instance.call("div", &[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 1276 +fn c1258_l1276_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1258_l1276_action_invoke"); + let result = instance.call("div", &[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 1277 +fn c1259_l1277_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1259_l1277_action_invoke"); + let result = instance.call("div", &[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 1278 +fn c1260_l1278_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1260_l1278_action_invoke"); + let result = instance.call("div", &[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 1279 +fn c1261_l1279_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1261_l1279_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1280 +fn c1262_l1280_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1262_l1280_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1281 +fn c1263_l1281_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1263_l1281_action_invoke"); + let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1282 +fn c1264_l1282_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1264_l1282_action_invoke"); + let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1283 +fn c1265_l1283_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1265_l1283_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1284 +fn c1266_l1284_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1266_l1284_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1285 +fn c1267_l1285_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1267_l1285_action_invoke"); + let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1286 +fn c1268_l1286_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1268_l1286_action_invoke"); + let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1287 +fn c1269_l1287_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1269_l1287_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1288 +fn c1270_l1288_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1270_l1288_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1289 +fn c1271_l1289_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1271_l1289_action_invoke"); + let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1290 +fn c1272_l1290_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1272_l1290_action_invoke"); + let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1291 +fn c1273_l1291_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1273_l1291_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1273_l1291_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1292 +fn c1274_l1292_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1274_l1292_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1274_l1292_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1293 +fn c1275_l1293_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1275_l1293_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1275_l1293_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1294 +fn c1276_l1294_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1276_l1294_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1276_l1294_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1295 +fn c1277_l1295_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1277_l1295_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1277_l1295_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1296 +fn c1278_l1296_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1278_l1296_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1278_l1296_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1297 +fn c1279_l1297_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1279_l1297_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1279_l1297_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1298 +fn c1280_l1298_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1280_l1298_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1280_l1298_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1299 +fn c1281_l1299_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1281_l1299_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1300 +fn c1282_l1300_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1282_l1300_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1301 +fn c1283_l1301_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1283_l1301_action_invoke"); + let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1302 +fn c1284_l1302_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1284_l1302_action_invoke"); + let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1303 +fn c1285_l1303_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1285_l1303_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((8388608.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1304 +fn c1286_l1304_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1286_l1304_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-8388608.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1305 +fn c1287_l1305_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1287_l1305_action_invoke"); + let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-8388608.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1306 +fn c1288_l1306_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1288_l1306_action_invoke"); + let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((8388608.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1307 +fn c1289_l1307_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1289_l1307_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1308 +fn c1290_l1308_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1290_l1308_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1309 +fn c1291_l1309_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1291_l1309_action_invoke"); + let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1310 +fn c1292_l1310_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1292_l1310_action_invoke"); + let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1311 +fn c1293_l1311_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1293_l1311_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000023509887f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1312 +fn c1294_l1312_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1294_l1312_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000023509887f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1313 +fn c1295_l1313_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1295_l1313_action_invoke"); + let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000023509887f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1314 +fn c1296_l1314_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1296_l1314_action_invoke"); + let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000023509887f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1315 +fn c1297_l1315_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1297_l1315_action_invoke"); + let result = instance.call("div", &[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 1316 +fn c1298_l1316_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1298_l1316_action_invoke"); + let result = instance.call("div", &[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 1317 +fn c1299_l1317_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1299_l1317_action_invoke"); + let result = instance.call("div", &[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 1318 +fn c1300_l1318_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1300_l1318_action_invoke"); + let result = instance.call("div", &[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 1319 +fn c1301_l1319_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1301_l1319_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000001870857f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1320 +fn c1302_l1320_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1302_l1320_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000001870857f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1321 +fn c1303_l1321_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1303_l1321_action_invoke"); + let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000001870857f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1322 +fn c1304_l1322_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1304_l1322_action_invoke"); + let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000001870857f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1323 +fn c1305_l1323_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1305_l1323_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1324 +fn c1306_l1324_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1306_l1324_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1325 +fn c1307_l1325_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1307_l1325_action_invoke"); + let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1326 +fn c1308_l1326_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1308_l1326_action_invoke"); + let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1327 +fn c1309_l1327_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1309_l1327_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1328 +fn c1310_l1328_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1310_l1328_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1329 +fn c1311_l1329_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1311_l1329_action_invoke"); + let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1330 +fn c1312_l1330_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1312_l1330_action_invoke"); + let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1331 +fn c1313_l1331_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1313_l1331_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1313_l1331_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1332 +fn c1314_l1332_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1314_l1332_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1314_l1332_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1333 +fn c1315_l1333_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1315_l1333_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1315_l1333_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1334 +fn c1316_l1334_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1316_l1334_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1316_l1334_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1335 +fn c1317_l1335_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1317_l1335_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1317_l1335_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1336 +fn c1318_l1336_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1318_l1336_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1318_l1336_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1337 +fn c1319_l1337_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1319_l1337_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1319_l1337_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1338 +fn c1320_l1338_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1320_l1338_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1320_l1338_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1339 +fn c1321_l1339_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1321_l1339_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1340 +fn c1322_l1340_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1322_l1340_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1341 +fn c1323_l1341_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1323_l1341_action_invoke"); + let result = instance.call("div", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1342 +fn c1324_l1342_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1324_l1342_action_invoke"); + let result = instance.call("div", &[Value::F32((0.5f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1343 +fn c1325_l1343_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1325_l1343_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1344 +fn c1326_l1344_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1326_l1344_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1345 +fn c1327_l1345_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1327_l1345_action_invoke"); + let result = instance.call("div", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1346 +fn c1328_l1346_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1328_l1346_action_invoke"); + let result = instance.call("div", &[Value::F32((0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1347 +fn c1329_l1347_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1329_l1347_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((42535296000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1348 +fn c1330_l1348_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1330_l1348_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-42535296000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1349 +fn c1331_l1349_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1331_l1349_action_invoke"); + let result = instance.call("div", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-42535296000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1350 +fn c1332_l1350_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1332_l1350_action_invoke"); + let result = instance.call("div", &[Value::F32((0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((42535296000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1351 +fn c1333_l1351_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1333_l1351_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1352 +fn c1334_l1352_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1334_l1352_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1353 +fn c1335_l1353_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1335_l1353_action_invoke"); + let result = instance.call("div", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1354 +fn c1336_l1354_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1336_l1354_action_invoke"); + let result = instance.call("div", &[Value::F32((0.5f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1355 +fn c1337_l1355_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1337_l1355_action_invoke"); + let result = instance.call("div", &[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 1356 +fn c1338_l1356_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1338_l1356_action_invoke"); + let result = instance.call("div", &[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 1357 +fn c1339_l1357_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1339_l1357_action_invoke"); + let result = instance.call("div", &[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 1358 +fn c1340_l1358_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1340_l1358_action_invoke"); + let result = instance.call("div", &[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 1359 +fn c1341_l1359_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1341_l1359_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.5f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.07957747f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1360 +fn c1342_l1360_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1342_l1360_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.5f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.07957747f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1361 +fn c1343_l1361_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1343_l1361_action_invoke"); + let result = instance.call("div", &[Value::F32((0.5f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.07957747f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1362 +fn c1344_l1362_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1344_l1362_action_invoke"); + let result = instance.call("div", &[Value::F32((0.5f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.07957747f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1363 +fn c1345_l1363_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1345_l1363_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.5f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000001469368f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1364 +fn c1346_l1364_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1346_l1364_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.5f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000001469368f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1365 +fn c1347_l1365_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1347_l1365_action_invoke"); + let result = instance.call("div", &[Value::F32((0.5f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000001469368f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1366 +fn c1348_l1366_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1348_l1366_action_invoke"); + let result = instance.call("div", &[Value::F32((0.5f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000001469368f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1367 +fn c1349_l1367_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1349_l1367_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1368 +fn c1350_l1368_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1350_l1368_action_invoke"); + let result = instance.call("div", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1369 +fn c1351_l1369_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1351_l1369_action_invoke"); + let result = instance.call("div", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1370 +fn c1352_l1370_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1352_l1370_action_invoke"); + let result = instance.call("div", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1371 +fn c1353_l1371_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1353_l1371_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1353_l1371_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1372 +fn c1354_l1372_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1354_l1372_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1354_l1372_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1373 +fn c1355_l1373_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1355_l1373_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1355_l1373_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1374 +fn c1356_l1374_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1356_l1374_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1356_l1374_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1375 +fn c1357_l1375_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1357_l1375_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1357_l1375_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1376 +fn c1358_l1376_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1358_l1376_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1358_l1376_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1377 +fn c1359_l1377_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1359_l1377_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1359_l1377_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1378 +fn c1360_l1378_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1360_l1378_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1360_l1378_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1379 +fn c1361_l1379_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1361_l1379_action_invoke"); + let result = instance.call("div", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1380 +fn c1362_l1380_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1362_l1380_action_invoke"); + let result = instance.call("div", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1381 +fn c1363_l1381_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1363_l1381_action_invoke"); + let result = instance.call("div", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1382 +fn c1364_l1382_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1364_l1382_action_invoke"); + let result = instance.call("div", &[Value::F32((1.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1383 +fn c1365_l1383_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1365_l1383_action_invoke"); + let result = instance.call("div", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1384 +fn c1366_l1384_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1366_l1384_action_invoke"); + let result = instance.call("div", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1385 +fn c1367_l1385_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1367_l1385_action_invoke"); + let result = instance.call("div", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1386 +fn c1368_l1386_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1368_l1386_action_invoke"); + let result = instance.call("div", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1387 +fn c1369_l1387_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1369_l1387_action_invoke"); + let result = instance.call("div", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((85070590000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1388 +fn c1370_l1388_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1370_l1388_action_invoke"); + let result = instance.call("div", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-85070590000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1389 +fn c1371_l1389_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1371_l1389_action_invoke"); + let result = instance.call("div", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-85070590000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1390 +fn c1372_l1390_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1372_l1390_action_invoke"); + let result = instance.call("div", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((85070590000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1391 +fn c1373_l1391_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1373_l1391_action_invoke"); + let result = instance.call("div", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((2.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1392 +fn c1374_l1392_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1374_l1392_action_invoke"); + let result = instance.call("div", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-2.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1393 +fn c1375_l1393_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1375_l1393_action_invoke"); + let result = instance.call("div", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-2.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1394 +fn c1376_l1394_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1376_l1394_action_invoke"); + let result = instance.call("div", &[Value::F32((1.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((2.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1395 +fn c1377_l1395_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1377_l1395_action_invoke"); + let result = instance.call("div", &[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 1396 +fn c1378_l1396_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1378_l1396_action_invoke"); + let result = instance.call("div", &[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 1397 +fn c1379_l1397_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1379_l1397_action_invoke"); + let result = instance.call("div", &[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 1398 +fn c1380_l1398_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1380_l1398_action_invoke"); + let result = instance.call("div", &[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 1399 +fn c1381_l1399_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1381_l1399_action_invoke"); + let result = instance.call("div", &[Value::F32((-1.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.15915494f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1400 +fn c1382_l1400_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1382_l1400_action_invoke"); + let result = instance.call("div", &[Value::F32((-1.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.15915494f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1401 +fn c1383_l1401_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1383_l1401_action_invoke"); + let result = instance.call("div", &[Value::F32((1.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.15915494f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1402 +fn c1384_l1402_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1384_l1402_action_invoke"); + let result = instance.call("div", &[Value::F32((1.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.15915494f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1403 +fn c1385_l1403_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1385_l1403_action_invoke"); + let result = instance.call("div", &[Value::F32((-1.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000002938736f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1404 +fn c1386_l1404_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1386_l1404_action_invoke"); + let result = instance.call("div", &[Value::F32((-1.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000002938736f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1405 +fn c1387_l1405_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1387_l1405_action_invoke"); + let result = instance.call("div", &[Value::F32((1.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000002938736f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1406 +fn c1388_l1406_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1388_l1406_action_invoke"); + let result = instance.call("div", &[Value::F32((1.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000002938736f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1407 +fn c1389_l1407_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1389_l1407_action_invoke"); + let result = instance.call("div", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1408 +fn c1390_l1408_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1390_l1408_action_invoke"); + let result = instance.call("div", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1409 +fn c1391_l1409_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1391_l1409_action_invoke"); + let result = instance.call("div", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1410 +fn c1392_l1410_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1392_l1410_action_invoke"); + let result = instance.call("div", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1411 +fn c1393_l1411_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1393_l1411_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1393_l1411_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1412 +fn c1394_l1412_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1394_l1412_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1394_l1412_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1413 +fn c1395_l1413_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1395_l1413_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1395_l1413_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1414 +fn c1396_l1414_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1396_l1414_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1396_l1414_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1415 +fn c1397_l1415_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1397_l1415_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1397_l1415_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1416 +fn c1398_l1416_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1398_l1416_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1398_l1416_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1417 +fn c1399_l1417_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1399_l1417_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1399_l1417_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1418 +fn c1400_l1418_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1400_l1418_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1400_l1418_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1419 +fn c1401_l1419_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1401_l1419_action_invoke"); + let result = instance.call("div", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1420 +fn c1402_l1420_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1402_l1420_action_invoke"); + let result = instance.call("div", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1421 +fn c1403_l1421_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1403_l1421_action_invoke"); + let result = instance.call("div", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1422 +fn c1404_l1422_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1404_l1422_action_invoke"); + let result = instance.call("div", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1423 +fn c1405_l1423_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1405_l1423_action_invoke"); + let result = instance.call("div", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1424 +fn c1406_l1424_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1406_l1424_action_invoke"); + let result = instance.call("div", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1425 +fn c1407_l1425_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1407_l1425_action_invoke"); + let result = instance.call("div", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1426 +fn c1408_l1426_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1408_l1426_action_invoke"); + let result = instance.call("div", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1427 +fn c1409_l1427_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1409_l1427_action_invoke"); + let result = instance.call("div", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1428 +fn c1410_l1428_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1410_l1428_action_invoke"); + let result = instance.call("div", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1429 +fn c1411_l1429_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1411_l1429_action_invoke"); + let result = instance.call("div", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1430 +fn c1412_l1430_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1412_l1430_action_invoke"); + let result = instance.call("div", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1431 +fn c1413_l1431_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1413_l1431_action_invoke"); + let result = instance.call("div", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((12.566371f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1432 +fn c1414_l1432_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1414_l1432_action_invoke"); + let result = instance.call("div", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-12.566371f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1433 +fn c1415_l1433_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1415_l1433_action_invoke"); + let result = instance.call("div", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-12.566371f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1434 +fn c1416_l1434_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1416_l1434_action_invoke"); + let result = instance.call("div", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((12.566371f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1435 +fn c1417_l1435_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1417_l1435_action_invoke"); + let result = instance.call("div", &[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 1436 +fn c1418_l1436_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1418_l1436_action_invoke"); + let result = instance.call("div", &[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 1437 +fn c1419_l1437_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1419_l1437_action_invoke"); + let result = instance.call("div", &[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 1438 +fn c1420_l1438_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1420_l1438_action_invoke"); + let result = instance.call("div", &[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 1439 +fn c1421_l1439_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1421_l1439_action_invoke"); + let result = instance.call("div", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1440 +fn c1422_l1440_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1422_l1440_action_invoke"); + let result = instance.call("div", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1441 +fn c1423_l1441_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1423_l1441_action_invoke"); + let result = instance.call("div", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1442 +fn c1424_l1442_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1424_l1442_action_invoke"); + let result = instance.call("div", &[Value::F32((6.2831855f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1443 +fn c1425_l1443_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1425_l1443_action_invoke"); + let result = instance.call("div", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000018464624f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1444 +fn c1426_l1444_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1426_l1444_action_invoke"); + let result = instance.call("div", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000018464624f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1445 +fn c1427_l1445_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1427_l1445_action_invoke"); + let result = instance.call("div", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000018464624f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1446 +fn c1428_l1446_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1428_l1446_action_invoke"); + let result = instance.call("div", &[Value::F32((6.2831855f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000018464624f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1447 +fn c1429_l1447_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1429_l1447_action_invoke"); + let result = instance.call("div", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1448 +fn c1430_l1448_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1430_l1448_action_invoke"); + let result = instance.call("div", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1449 +fn c1431_l1449_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1431_l1449_action_invoke"); + let result = instance.call("div", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1450 +fn c1432_l1450_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1432_l1450_action_invoke"); + let result = instance.call("div", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1451 +fn c1433_l1451_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1433_l1451_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1433_l1451_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1452 +fn c1434_l1452_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1434_l1452_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1434_l1452_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1453 +fn c1435_l1453_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1435_l1453_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1435_l1453_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1454 +fn c1436_l1454_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1436_l1454_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1436_l1454_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1455 +fn c1437_l1455_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1437_l1455_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1437_l1455_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1456 +fn c1438_l1456_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1438_l1456_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1438_l1456_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1457 +fn c1439_l1457_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1439_l1457_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1439_l1457_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1458 +fn c1440_l1458_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1440_l1458_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1440_l1458_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1459 +fn c1441_l1459_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1441_l1459_action_invoke"); + let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1460 +fn c1442_l1460_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1442_l1460_action_invoke"); + let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1461 +fn c1443_l1461_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1443_l1461_action_invoke"); + let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1462 +fn c1444_l1462_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1444_l1462_action_invoke"); + let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1463 +fn c1445_l1463_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1445_l1463_action_invoke"); + let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1464 +fn c1446_l1464_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1446_l1464_action_invoke"); + let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1465 +fn c1447_l1465_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1447_l1465_action_invoke"); + let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1466 +fn c1448_l1466_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1448_l1466_action_invoke"); + let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1467 +fn c1449_l1467_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1449_l1467_action_invoke"); + let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1468 +fn c1450_l1468_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1450_l1468_action_invoke"); + let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1469 +fn c1451_l1469_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1451_l1469_action_invoke"); + let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1470 +fn c1452_l1470_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1452_l1470_action_invoke"); + let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1471 +fn c1453_l1471_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1453_l1471_action_invoke"); + let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1472 +fn c1454_l1472_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1454_l1472_action_invoke"); + let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1473 +fn c1455_l1473_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1455_l1473_action_invoke"); + let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1474 +fn c1456_l1474_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1456_l1474_action_invoke"); + let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1475 +fn c1457_l1475_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1457_l1475_action_invoke"); + let result = instance.call("div", &[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 1476 +fn c1458_l1476_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1458_l1476_action_invoke"); + let result = instance.call("div", &[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 1477 +fn c1459_l1477_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1459_l1477_action_invoke"); + let result = instance.call("div", &[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 1478 +fn c1460_l1478_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1460_l1478_action_invoke"); + let result = instance.call("div", &[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 1479 +fn c1461_l1479_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1461_l1479_action_invoke"); + let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((54157613000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1480 +fn c1462_l1480_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1462_l1480_action_invoke"); + let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-54157613000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1481 +fn c1463_l1481_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1463_l1481_action_invoke"); + let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-54157613000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1482 +fn c1464_l1482_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1464_l1482_action_invoke"); + let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((54157613000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1483 +fn c1465_l1483_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1465_l1483_action_invoke"); + let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1484 +fn c1466_l1484_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1466_l1484_action_invoke"); + let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1485 +fn c1467_l1485_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1467_l1485_action_invoke"); + let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1486 +fn c1468_l1486_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1468_l1486_action_invoke"); + let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1487 +fn c1469_l1487_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1469_l1487_action_invoke"); + let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1488 +fn c1470_l1488_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1470_l1488_action_invoke"); + let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1489 +fn c1471_l1489_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1471_l1489_action_invoke"); + let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1490 +fn c1472_l1490_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1472_l1490_action_invoke"); + let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1491 +fn c1473_l1491_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1473_l1491_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1473_l1491_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1492 +fn c1474_l1492_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1474_l1492_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1474_l1492_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1493 +fn c1475_l1493_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1475_l1493_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1475_l1493_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1494 +fn c1476_l1494_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1476_l1494_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1476_l1494_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1495 +fn c1477_l1495_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1477_l1495_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1477_l1495_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1496 +fn c1478_l1496_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1478_l1496_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1478_l1496_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1497 +fn c1479_l1497_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1479_l1497_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1479_l1497_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1498 +fn c1480_l1498_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1480_l1498_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1480_l1498_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1499 +fn c1481_l1499_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1481_l1499_action_invoke"); + let result = instance.call("div", &[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 1500 +fn c1482_l1500_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1482_l1500_action_invoke"); + let result = instance.call("div", &[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 1501 +fn c1483_l1501_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1483_l1501_action_invoke"); + let result = instance.call("div", &[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 1502 +fn c1484_l1502_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1484_l1502_action_invoke"); + let result = instance.call("div", &[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 1503 +fn c1485_l1503_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1485_l1503_action_invoke"); + let result = instance.call("div", &[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 1504 +fn c1486_l1504_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1486_l1504_action_invoke"); + let result = instance.call("div", &[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 1505 +fn c1487_l1505_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1487_l1505_action_invoke"); + let result = instance.call("div", &[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 1506 +fn c1488_l1506_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1488_l1506_action_invoke"); + let result = instance.call("div", &[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 1507 +fn c1489_l1507_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1489_l1507_action_invoke"); + let result = instance.call("div", &[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 1508 +fn c1490_l1508_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1490_l1508_action_invoke"); + let result = instance.call("div", &[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 1509 +fn c1491_l1509_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1491_l1509_action_invoke"); + let result = instance.call("div", &[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 1510 +fn c1492_l1510_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1492_l1510_action_invoke"); + let result = instance.call("div", &[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 1511 +fn c1493_l1511_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1493_l1511_action_invoke"); + let result = instance.call("div", &[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 1512 +fn c1494_l1512_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1494_l1512_action_invoke"); + let result = instance.call("div", &[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 1513 +fn c1495_l1513_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1495_l1513_action_invoke"); + let result = instance.call("div", &[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 1514 +fn c1496_l1514_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1496_l1514_action_invoke"); + let result = instance.call("div", &[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 1515 +fn c1497_l1515_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1497_l1515_action_invoke"); + let result = instance.call("div", &[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 1516 +fn c1498_l1516_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1498_l1516_action_invoke"); + let result = instance.call("div", &[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 1517 +fn c1499_l1517_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1499_l1517_action_invoke"); + let result = instance.call("div", &[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 1518 +fn c1500_l1518_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1500_l1518_action_invoke"); + let result = instance.call("div", &[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 1519 +fn c1501_l1519_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1501_l1519_action_invoke"); + let result = instance.call("div", &[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 1520 +fn c1502_l1520_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1502_l1520_action_invoke"); + let result = instance.call("div", &[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 1521 +fn c1503_l1521_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1503_l1521_action_invoke"); + let result = instance.call("div", &[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 1522 +fn c1504_l1522_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1504_l1522_action_invoke"); + let result = instance.call("div", &[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 1523 +fn c1505_l1523_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1505_l1523_action_invoke"); + let result = instance.call("div", &[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 1524 +fn c1506_l1524_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1506_l1524_action_invoke"); + let result = instance.call("div", &[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 1525 +fn c1507_l1525_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1507_l1525_action_invoke"); + let result = instance.call("div", &[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 1526 +fn c1508_l1526_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1508_l1526_action_invoke"); + let result = instance.call("div", &[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 1527 +fn c1509_l1527_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1509_l1527_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1509_l1527_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1528 +fn c1510_l1528_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1510_l1528_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c1510_l1528_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1529 +fn c1511_l1529_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1511_l1529_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1511_l1529_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1530 +fn c1512_l1530_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1512_l1530_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c1512_l1530_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1531 +fn c1513_l1531_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1513_l1531_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1513_l1531_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1532 +fn c1514_l1532_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1514_l1532_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1514_l1532_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1533 +fn c1515_l1533_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1515_l1533_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1515_l1533_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1534 +fn c1516_l1534_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1516_l1534_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1516_l1534_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1535 +fn c1517_l1535_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1517_l1535_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1517_l1535_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1536 +fn c1518_l1536_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1518_l1536_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1518_l1536_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1537 +fn c1519_l1537_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1519_l1537_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1519_l1537_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1538 +fn c1520_l1538_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1520_l1538_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1520_l1538_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1539 +fn c1521_l1539_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1521_l1539_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c1521_l1539_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1540 +fn c1522_l1540_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1522_l1540_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c1522_l1540_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1541 +fn c1523_l1541_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1523_l1541_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c1523_l1541_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1542 +fn c1524_l1542_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1524_l1542_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c1524_l1542_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1543 +fn c1525_l1543_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1525_l1543_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c1525_l1543_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1544 +fn c1526_l1544_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1526_l1544_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c1526_l1544_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1545 +fn c1527_l1545_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1527_l1545_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c1527_l1545_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1546 +fn c1528_l1546_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1528_l1546_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c1528_l1546_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1547 +fn c1529_l1547_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1529_l1547_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1529_l1547_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1548 +fn c1530_l1548_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1530_l1548_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1530_l1548_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1549 +fn c1531_l1549_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1531_l1549_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1531_l1549_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1550 +fn c1532_l1550_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1532_l1550_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1532_l1550_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1551 +fn c1533_l1551_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1533_l1551_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1533_l1551_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1552 +fn c1534_l1552_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1534_l1552_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1534_l1552_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1553 +fn c1535_l1553_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1535_l1553_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1535_l1553_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1554 +fn c1536_l1554_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1536_l1554_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1536_l1554_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1555 +fn c1537_l1555_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1537_l1555_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1537_l1555_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1556 +fn c1538_l1556_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1538_l1556_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1538_l1556_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1557 +fn c1539_l1557_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1539_l1557_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1539_l1557_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1558 +fn c1540_l1558_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1540_l1558_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1540_l1558_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1559 +fn c1541_l1559_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1541_l1559_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1541_l1559_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1560 +fn c1542_l1560_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1542_l1560_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1542_l1560_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1561 +fn c1543_l1561_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1543_l1561_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1543_l1561_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1562 +fn c1544_l1562_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1544_l1562_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1544_l1562_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1563 +fn c1545_l1563_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1545_l1563_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c1545_l1563_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1564 +fn c1546_l1564_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1546_l1564_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c1546_l1564_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1565 +fn c1547_l1565_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1547_l1565_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c1547_l1565_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1566 +fn c1548_l1566_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1548_l1566_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c1548_l1566_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1567 +fn c1549_l1567_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1549_l1567_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c1549_l1567_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1568 +fn c1550_l1568_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1550_l1568_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c1550_l1568_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1569 +fn c1551_l1569_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1551_l1569_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c1551_l1569_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1570 +fn c1552_l1570_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1552_l1570_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c1552_l1570_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1571 +fn c1553_l1571_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1553_l1571_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c1553_l1571_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1572 +fn c1554_l1572_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1554_l1572_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c1554_l1572_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1573 +fn c1555_l1573_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1555_l1573_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c1555_l1573_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1574 +fn c1556_l1574_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1556_l1574_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c1556_l1574_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1575 +fn c1557_l1575_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1557_l1575_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c1557_l1575_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1576 +fn c1558_l1576_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1558_l1576_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c1558_l1576_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1577 +fn c1559_l1577_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1559_l1577_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c1559_l1577_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1578 +fn c1560_l1578_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1560_l1578_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c1560_l1578_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1579 +fn c1561_l1579_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1561_l1579_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1561_l1579_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1580 +fn c1562_l1580_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1562_l1580_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1562_l1580_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1581 +fn c1563_l1581_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1563_l1581_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1563_l1581_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1582 +fn c1564_l1582_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1564_l1582_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1564_l1582_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1583 +fn c1565_l1583_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1565_l1583_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1565_l1583_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1584 +fn c1566_l1584_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1566_l1584_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1566_l1584_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1585 +fn c1567_l1585_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1567_l1585_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1567_l1585_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1586 +fn c1568_l1586_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1568_l1586_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1568_l1586_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1587 +fn c1569_l1587_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1569_l1587_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1569_l1587_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1588 +fn c1570_l1588_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1570_l1588_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1570_l1588_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1589 +fn c1571_l1589_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1571_l1589_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1571_l1589_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1590 +fn c1572_l1590_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1572_l1590_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1572_l1590_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1591 +fn c1573_l1591_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1573_l1591_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1573_l1591_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1592 +fn c1574_l1592_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1574_l1592_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1574_l1592_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1593 +fn c1575_l1593_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1575_l1593_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1575_l1593_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1594 +fn c1576_l1594_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1576_l1594_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1576_l1594_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1595 +fn c1577_l1595_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1577_l1595_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1577_l1595_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1596 +fn c1578_l1596_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1578_l1596_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1578_l1596_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1597 +fn c1579_l1597_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1579_l1597_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c1579_l1597_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1598 +fn c1580_l1598_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1580_l1598_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c1580_l1598_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1599 +fn c1581_l1599_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1581_l1599_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1581_l1599_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1600 +fn c1582_l1600_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1582_l1600_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1582_l1600_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1601 +fn c1583_l1601_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1583_l1601_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c1583_l1601_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1602 +fn c1584_l1602_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1584_l1602_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c1584_l1602_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1603 +fn c1585_l1603_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1585_l1603_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1585_l1603_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1604 +fn c1586_l1604_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1586_l1604_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1586_l1604_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1605 +fn c1587_l1605_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1587_l1605_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1587_l1605_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1606 +fn c1588_l1606_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1588_l1606_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1588_l1606_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1607 +fn c1589_l1607_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1589_l1607_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1589_l1607_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1608 +fn c1590_l1608_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1590_l1608_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1590_l1608_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1609 +fn c1591_l1609_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1591_l1609_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1591_l1609_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1610 +fn c1592_l1610_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1592_l1610_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1592_l1610_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1611 +fn c1593_l1611_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1593_l1611_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1593_l1611_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1612 +fn c1594_l1612_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1594_l1612_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1594_l1612_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1613 +fn c1595_l1613_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1595_l1613_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1595_l1613_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1614 +fn c1596_l1614_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1596_l1614_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1596_l1614_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1615 +fn c1597_l1615_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1597_l1615_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1597_l1615_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1616 +fn c1598_l1616_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1598_l1616_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1598_l1616_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1617 +fn c1599_l1617_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1599_l1617_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1599_l1617_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1618 +fn c1600_l1618_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1600_l1618_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1600_l1618_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1619 +fn c1601_l1619_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1601_l1619_action_invoke"); + let result = instance.call("min", &[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 1620 +fn c1602_l1620_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1602_l1620_action_invoke"); + let result = instance.call("min", &[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 1621 +fn c1603_l1621_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1603_l1621_action_invoke"); + let result = instance.call("min", &[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 1622 +fn c1604_l1622_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1604_l1622_action_invoke"); + let result = instance.call("min", &[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 1623 +fn c1605_l1623_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1605_l1623_action_invoke"); + let result = instance.call("min", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1624 +fn c1606_l1624_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1606_l1624_action_invoke"); + let result = instance.call("min", &[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 1625 +fn c1607_l1625_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1607_l1625_action_invoke"); + let result = instance.call("min", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1626 +fn c1608_l1626_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1608_l1626_action_invoke"); + let result = instance.call("min", &[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 1627 +fn c1609_l1627_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1609_l1627_action_invoke"); + let result = instance.call("min", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1628 +fn c1610_l1628_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1610_l1628_action_invoke"); + let result = instance.call("min", &[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 1629 +fn c1611_l1629_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1611_l1629_action_invoke"); + let result = instance.call("min", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1630 +fn c1612_l1630_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1612_l1630_action_invoke"); + let result = instance.call("min", &[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 1631 +fn c1613_l1631_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1613_l1631_action_invoke"); + let result = instance.call("min", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1632 +fn c1614_l1632_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1614_l1632_action_invoke"); + let result = instance.call("min", &[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 1633 +fn c1615_l1633_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1615_l1633_action_invoke"); + let result = instance.call("min", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1634 +fn c1616_l1634_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1616_l1634_action_invoke"); + let result = instance.call("min", &[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 1635 +fn c1617_l1635_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1617_l1635_action_invoke"); + let result = instance.call("min", &[Value::F32((-0.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1636 +fn c1618_l1636_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1618_l1636_action_invoke"); + let result = instance.call("min", &[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 1637 +fn c1619_l1637_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1619_l1637_action_invoke"); + let result = instance.call("min", &[Value::F32((0.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1638 +fn c1620_l1638_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1620_l1638_action_invoke"); + let result = instance.call("min", &[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 1639 +fn c1621_l1639_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1621_l1639_action_invoke"); + let result = instance.call("min", &[Value::F32((-0.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1640 +fn c1622_l1640_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1622_l1640_action_invoke"); + let result = instance.call("min", &[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 1641 +fn c1623_l1641_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1623_l1641_action_invoke"); + let result = instance.call("min", &[Value::F32((0.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1642 +fn c1624_l1642_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1624_l1642_action_invoke"); + let result = instance.call("min", &[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 1643 +fn c1625_l1643_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1625_l1643_action_invoke"); + let result = instance.call("min", &[Value::F32((-0.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1644 +fn c1626_l1644_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1626_l1644_action_invoke"); + let result = instance.call("min", &[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 1645 +fn c1627_l1645_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1627_l1645_action_invoke"); + let result = instance.call("min", &[Value::F32((0.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1646 +fn c1628_l1646_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1628_l1646_action_invoke"); + let result = instance.call("min", &[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 1647 +fn c1629_l1647_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1629_l1647_action_invoke"); + let result = instance.call("min", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1648 +fn c1630_l1648_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1630_l1648_action_invoke"); + let result = instance.call("min", &[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 1649 +fn c1631_l1649_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1631_l1649_action_invoke"); + let result = instance.call("min", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1650 +fn c1632_l1650_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1632_l1650_action_invoke"); + let result = instance.call("min", &[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 1651 +fn c1633_l1651_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1633_l1651_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1633_l1651_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1652 +fn c1634_l1652_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1634_l1652_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1634_l1652_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1653 +fn c1635_l1653_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1635_l1653_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1635_l1653_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1654 +fn c1636_l1654_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1636_l1654_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1636_l1654_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1655 +fn c1637_l1655_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1637_l1655_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1637_l1655_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1656 +fn c1638_l1656_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1638_l1656_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1638_l1656_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1657 +fn c1639_l1657_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1639_l1657_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1639_l1657_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1658 +fn c1640_l1658_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1640_l1658_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1640_l1658_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1659 +fn c1641_l1659_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1641_l1659_action_invoke"); + let result = instance.call("min", &[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 1660 +fn c1642_l1660_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1642_l1660_action_invoke"); + let result = instance.call("min", &[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 1661 +fn c1643_l1661_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1643_l1661_action_invoke"); + let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1662 +fn c1644_l1662_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1644_l1662_action_invoke"); + let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1663 +fn c1645_l1663_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1645_l1663_action_invoke"); + let result = instance.call("min", &[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 1664 +fn c1646_l1664_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1646_l1664_action_invoke"); + let result = instance.call("min", &[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 1665 +fn c1647_l1665_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1647_l1665_action_invoke"); + let result = instance.call("min", &[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 1666 +fn c1648_l1666_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1648_l1666_action_invoke"); + let result = instance.call("min", &[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 1667 +fn c1649_l1667_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1649_l1667_action_invoke"); + let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1668 +fn c1650_l1668_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1650_l1668_action_invoke"); + let result = instance.call("min", &[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 1669 +fn c1651_l1669_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1651_l1669_action_invoke"); + let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1670 +fn c1652_l1670_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1652_l1670_action_invoke"); + let result = instance.call("min", &[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 1671 +fn c1653_l1671_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1653_l1671_action_invoke"); + let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1672 +fn c1654_l1672_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1654_l1672_action_invoke"); + let result = instance.call("min", &[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 1673 +fn c1655_l1673_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1655_l1673_action_invoke"); + let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1674 +fn c1656_l1674_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1656_l1674_action_invoke"); + let result = instance.call("min", &[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 1675 +fn c1657_l1675_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1657_l1675_action_invoke"); + let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1676 +fn c1658_l1676_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1658_l1676_action_invoke"); + let result = instance.call("min", &[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 1677 +fn c1659_l1677_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1659_l1677_action_invoke"); + let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1678 +fn c1660_l1678_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1660_l1678_action_invoke"); + let result = instance.call("min", &[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 1679 +fn c1661_l1679_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1661_l1679_action_invoke"); + let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1680 +fn c1662_l1680_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1662_l1680_action_invoke"); + let result = instance.call("min", &[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 1681 +fn c1663_l1681_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1663_l1681_action_invoke"); + let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1682 +fn c1664_l1682_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1664_l1682_action_invoke"); + let result = instance.call("min", &[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 1683 +fn c1665_l1683_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1665_l1683_action_invoke"); + let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1684 +fn c1666_l1684_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1666_l1684_action_invoke"); + let result = instance.call("min", &[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 1685 +fn c1667_l1685_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1667_l1685_action_invoke"); + let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1686 +fn c1668_l1686_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1668_l1686_action_invoke"); + let result = instance.call("min", &[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 1687 +fn c1669_l1687_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1669_l1687_action_invoke"); + let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1688 +fn c1670_l1688_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1670_l1688_action_invoke"); + let result = instance.call("min", &[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 1689 +fn c1671_l1689_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1671_l1689_action_invoke"); + let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1690 +fn c1672_l1690_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1672_l1690_action_invoke"); + let result = instance.call("min", &[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 1691 +fn c1673_l1691_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1673_l1691_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1673_l1691_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1692 +fn c1674_l1692_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1674_l1692_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1674_l1692_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1693 +fn c1675_l1693_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1675_l1693_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1675_l1693_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1694 +fn c1676_l1694_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1676_l1694_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1676_l1694_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1695 +fn c1677_l1695_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1677_l1695_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1677_l1695_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1696 +fn c1678_l1696_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1678_l1696_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1678_l1696_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1697 +fn c1679_l1697_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1679_l1697_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1679_l1697_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1698 +fn c1680_l1698_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1680_l1698_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1680_l1698_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1699 +fn c1681_l1699_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1681_l1699_action_invoke"); + let result = instance.call("min", &[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 1700 +fn c1682_l1700_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1682_l1700_action_invoke"); + let result = instance.call("min", &[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 1701 +fn c1683_l1701_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1683_l1701_action_invoke"); + let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1702 +fn c1684_l1702_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1684_l1702_action_invoke"); + let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1703 +fn c1685_l1703_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1685_l1703_action_invoke"); + let result = instance.call("min", &[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 1704 +fn c1686_l1704_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1686_l1704_action_invoke"); + let result = instance.call("min", &[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 1705 +fn c1687_l1705_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1687_l1705_action_invoke"); + let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1706 +fn c1688_l1706_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1688_l1706_action_invoke"); + let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1707 +fn c1689_l1707_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1689_l1707_action_invoke"); + let result = instance.call("min", &[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 1708 +fn c1690_l1708_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1690_l1708_action_invoke"); + let result = instance.call("min", &[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 1709 +fn c1691_l1709_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1691_l1709_action_invoke"); + let result = instance.call("min", &[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 1710 +fn c1692_l1710_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1692_l1710_action_invoke"); + let result = instance.call("min", &[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 1711 +fn c1693_l1711_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1693_l1711_action_invoke"); + let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1712 +fn c1694_l1712_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1694_l1712_action_invoke"); + let result = instance.call("min", &[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 1713 +fn c1695_l1713_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1695_l1713_action_invoke"); + let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1714 +fn c1696_l1714_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1696_l1714_action_invoke"); + let result = instance.call("min", &[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 1715 +fn c1697_l1715_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1697_l1715_action_invoke"); + let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1716 +fn c1698_l1716_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1698_l1716_action_invoke"); + let result = instance.call("min", &[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 1717 +fn c1699_l1717_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1699_l1717_action_invoke"); + let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1718 +fn c1700_l1718_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1700_l1718_action_invoke"); + let result = instance.call("min", &[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 1719 +fn c1701_l1719_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1701_l1719_action_invoke"); + let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1720 +fn c1702_l1720_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1702_l1720_action_invoke"); + let result = instance.call("min", &[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 1721 +fn c1703_l1721_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1703_l1721_action_invoke"); + let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1722 +fn c1704_l1722_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1704_l1722_action_invoke"); + let result = instance.call("min", &[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 1723 +fn c1705_l1723_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1705_l1723_action_invoke"); + let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1724 +fn c1706_l1724_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1706_l1724_action_invoke"); + let result = instance.call("min", &[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 1725 +fn c1707_l1725_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1707_l1725_action_invoke"); + let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1726 +fn c1708_l1726_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1708_l1726_action_invoke"); + let result = instance.call("min", &[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 1727 +fn c1709_l1727_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1709_l1727_action_invoke"); + let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1728 +fn c1710_l1728_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1710_l1728_action_invoke"); + let result = instance.call("min", &[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 1729 +fn c1711_l1729_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1711_l1729_action_invoke"); + let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1730 +fn c1712_l1730_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1712_l1730_action_invoke"); + let result = instance.call("min", &[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 1731 +fn c1713_l1731_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1713_l1731_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1713_l1731_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1732 +fn c1714_l1732_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1714_l1732_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1714_l1732_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1733 +fn c1715_l1733_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1715_l1733_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1715_l1733_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1734 +fn c1716_l1734_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1716_l1734_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1716_l1734_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1735 +fn c1717_l1735_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1717_l1735_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1717_l1735_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1736 +fn c1718_l1736_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1718_l1736_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1718_l1736_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1737 +fn c1719_l1737_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1719_l1737_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1719_l1737_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1738 +fn c1720_l1738_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1720_l1738_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1720_l1738_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1739 +fn c1721_l1739_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1721_l1739_action_invoke"); + let result = instance.call("min", &[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 1740 +fn c1722_l1740_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1722_l1740_action_invoke"); + let result = instance.call("min", &[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 1741 +fn c1723_l1741_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1723_l1741_action_invoke"); + let result = instance.call("min", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1742 +fn c1724_l1742_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1724_l1742_action_invoke"); + let result = instance.call("min", &[Value::F32((0.5f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1743 +fn c1725_l1743_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1725_l1743_action_invoke"); + let result = instance.call("min", &[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 1744 +fn c1726_l1744_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1726_l1744_action_invoke"); + let result = instance.call("min", &[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 1745 +fn c1727_l1745_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1727_l1745_action_invoke"); + let result = instance.call("min", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1746 +fn c1728_l1746_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1728_l1746_action_invoke"); + let result = instance.call("min", &[Value::F32((0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1747 +fn c1729_l1747_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1729_l1747_action_invoke"); + let result = instance.call("min", &[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 1748 +fn c1730_l1748_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1730_l1748_action_invoke"); + let result = instance.call("min", &[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 1749 +fn c1731_l1749_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1731_l1749_action_invoke"); + let result = instance.call("min", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1750 +fn c1732_l1750_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1732_l1750_action_invoke"); + let result = instance.call("min", &[Value::F32((0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1751 +fn c1733_l1751_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1733_l1751_action_invoke"); + let result = instance.call("min", &[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 1752 +fn c1734_l1752_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1734_l1752_action_invoke"); + let result = instance.call("min", &[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 1753 +fn c1735_l1753_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1735_l1753_action_invoke"); + let result = instance.call("min", &[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 1754 +fn c1736_l1754_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1736_l1754_action_invoke"); + let result = instance.call("min", &[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 1755 +fn c1737_l1755_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1737_l1755_action_invoke"); + let result = instance.call("min", &[Value::F32((-0.5f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1756 +fn c1738_l1756_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1738_l1756_action_invoke"); + let result = instance.call("min", &[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 1757 +fn c1739_l1757_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1739_l1757_action_invoke"); + let result = instance.call("min", &[Value::F32((0.5f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1758 +fn c1740_l1758_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1740_l1758_action_invoke"); + let result = instance.call("min", &[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 1759 +fn c1741_l1759_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1741_l1759_action_invoke"); + let result = instance.call("min", &[Value::F32((-0.5f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1760 +fn c1742_l1760_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1742_l1760_action_invoke"); + let result = instance.call("min", &[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 1761 +fn c1743_l1761_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1743_l1761_action_invoke"); + let result = instance.call("min", &[Value::F32((0.5f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1762 +fn c1744_l1762_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1744_l1762_action_invoke"); + let result = instance.call("min", &[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 1763 +fn c1745_l1763_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1745_l1763_action_invoke"); + let result = instance.call("min", &[Value::F32((-0.5f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1764 +fn c1746_l1764_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1746_l1764_action_invoke"); + let result = instance.call("min", &[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 1765 +fn c1747_l1765_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1747_l1765_action_invoke"); + let result = instance.call("min", &[Value::F32((0.5f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1766 +fn c1748_l1766_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1748_l1766_action_invoke"); + let result = instance.call("min", &[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 1767 +fn c1749_l1767_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1749_l1767_action_invoke"); + let result = instance.call("min", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1768 +fn c1750_l1768_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1750_l1768_action_invoke"); + let result = instance.call("min", &[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 1769 +fn c1751_l1769_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1751_l1769_action_invoke"); + let result = instance.call("min", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1770 +fn c1752_l1770_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1752_l1770_action_invoke"); + let result = instance.call("min", &[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 1771 +fn c1753_l1771_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1753_l1771_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1753_l1771_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1772 +fn c1754_l1772_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1754_l1772_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1754_l1772_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1773 +fn c1755_l1773_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1755_l1773_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1755_l1773_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1774 +fn c1756_l1774_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1756_l1774_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1756_l1774_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1775 +fn c1757_l1775_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1757_l1775_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1757_l1775_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1776 +fn c1758_l1776_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1758_l1776_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1758_l1776_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1777 +fn c1759_l1777_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1759_l1777_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1759_l1777_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1778 +fn c1760_l1778_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1760_l1778_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1760_l1778_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1779 +fn c1761_l1779_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1761_l1779_action_invoke"); + let result = instance.call("min", &[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 1780 +fn c1762_l1780_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1762_l1780_action_invoke"); + let result = instance.call("min", &[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 1781 +fn c1763_l1781_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1763_l1781_action_invoke"); + let result = instance.call("min", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1782 +fn c1764_l1782_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1764_l1782_action_invoke"); + let result = instance.call("min", &[Value::F32((1.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1783 +fn c1765_l1783_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1765_l1783_action_invoke"); + let result = instance.call("min", &[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 1784 +fn c1766_l1784_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1766_l1784_action_invoke"); + let result = instance.call("min", &[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 1785 +fn c1767_l1785_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1767_l1785_action_invoke"); + let result = instance.call("min", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1786 +fn c1768_l1786_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1768_l1786_action_invoke"); + let result = instance.call("min", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1787 +fn c1769_l1787_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1769_l1787_action_invoke"); + let result = instance.call("min", &[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 1788 +fn c1770_l1788_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1770_l1788_action_invoke"); + let result = instance.call("min", &[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 1789 +fn c1771_l1789_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1771_l1789_action_invoke"); + let result = instance.call("min", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1790 +fn c1772_l1790_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1772_l1790_action_invoke"); + let result = instance.call("min", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1791 +fn c1773_l1791_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1773_l1791_action_invoke"); + let result = instance.call("min", &[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 1792 +fn c1774_l1792_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1774_l1792_action_invoke"); + let result = instance.call("min", &[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 1793 +fn c1775_l1793_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1775_l1793_action_invoke"); + let result = instance.call("min", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1794 +fn c1776_l1794_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1776_l1794_action_invoke"); + let result = instance.call("min", &[Value::F32((1.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1795 +fn c1777_l1795_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1777_l1795_action_invoke"); + let result = instance.call("min", &[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 1796 +fn c1778_l1796_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1778_l1796_action_invoke"); + let result = instance.call("min", &[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 1797 +fn c1779_l1797_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1779_l1797_action_invoke"); + let result = instance.call("min", &[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 1798 +fn c1780_l1798_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1780_l1798_action_invoke"); + let result = instance.call("min", &[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 1799 +fn c1781_l1799_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1781_l1799_action_invoke"); + let result = instance.call("min", &[Value::F32((-1.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1800 +fn c1782_l1800_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1782_l1800_action_invoke"); + let result = instance.call("min", &[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 1801 +fn c1783_l1801_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1783_l1801_action_invoke"); + let result = instance.call("min", &[Value::F32((1.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1802 +fn c1784_l1802_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1784_l1802_action_invoke"); + let result = instance.call("min", &[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 1803 +fn c1785_l1803_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1785_l1803_action_invoke"); + let result = instance.call("min", &[Value::F32((-1.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1804 +fn c1786_l1804_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1786_l1804_action_invoke"); + let result = instance.call("min", &[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 1805 +fn c1787_l1805_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1787_l1805_action_invoke"); + let result = instance.call("min", &[Value::F32((1.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1806 +fn c1788_l1806_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1788_l1806_action_invoke"); + let result = instance.call("min", &[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 1807 +fn c1789_l1807_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1789_l1807_action_invoke"); + let result = instance.call("min", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1808 +fn c1790_l1808_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1790_l1808_action_invoke"); + let result = instance.call("min", &[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 1809 +fn c1791_l1809_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1791_l1809_action_invoke"); + let result = instance.call("min", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1810 +fn c1792_l1810_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1792_l1810_action_invoke"); + let result = instance.call("min", &[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 1811 +fn c1793_l1811_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1793_l1811_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1793_l1811_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1812 +fn c1794_l1812_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1794_l1812_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1794_l1812_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1813 +fn c1795_l1813_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1795_l1813_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1795_l1813_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1814 +fn c1796_l1814_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1796_l1814_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1796_l1814_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1815 +fn c1797_l1815_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1797_l1815_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1797_l1815_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1816 +fn c1798_l1816_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1798_l1816_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1798_l1816_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1817 +fn c1799_l1817_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1799_l1817_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1799_l1817_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1818 +fn c1800_l1818_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1800_l1818_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1800_l1818_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1819 +fn c1801_l1819_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1801_l1819_action_invoke"); + let result = instance.call("min", &[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 1820 +fn c1802_l1820_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1802_l1820_action_invoke"); + let result = instance.call("min", &[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 1821 +fn c1803_l1821_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1803_l1821_action_invoke"); + let result = instance.call("min", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1822 +fn c1804_l1822_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1804_l1822_action_invoke"); + let result = instance.call("min", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1823 +fn c1805_l1823_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1805_l1823_action_invoke"); + let result = instance.call("min", &[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 1824 +fn c1806_l1824_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1806_l1824_action_invoke"); + let result = instance.call("min", &[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 1825 +fn c1807_l1825_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1807_l1825_action_invoke"); + let result = instance.call("min", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1826 +fn c1808_l1826_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1808_l1826_action_invoke"); + let result = instance.call("min", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1827 +fn c1809_l1827_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1809_l1827_action_invoke"); + let result = instance.call("min", &[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 1828 +fn c1810_l1828_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1810_l1828_action_invoke"); + let result = instance.call("min", &[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 1829 +fn c1811_l1829_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1811_l1829_action_invoke"); + let result = instance.call("min", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1830 +fn c1812_l1830_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1812_l1830_action_invoke"); + let result = instance.call("min", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1831 +fn c1813_l1831_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1813_l1831_action_invoke"); + let result = instance.call("min", &[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 1832 +fn c1814_l1832_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1814_l1832_action_invoke"); + let result = instance.call("min", &[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 1833 +fn c1815_l1833_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1815_l1833_action_invoke"); + let result = instance.call("min", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1834 +fn c1816_l1834_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1816_l1834_action_invoke"); + let result = instance.call("min", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1835 +fn c1817_l1835_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1817_l1835_action_invoke"); + let result = instance.call("min", &[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 1836 +fn c1818_l1836_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1818_l1836_action_invoke"); + let result = instance.call("min", &[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 1837 +fn c1819_l1837_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1819_l1837_action_invoke"); + let result = instance.call("min", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1838 +fn c1820_l1838_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1820_l1838_action_invoke"); + let result = instance.call("min", &[Value::F32((6.2831855f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1839 +fn c1821_l1839_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1821_l1839_action_invoke"); + let result = instance.call("min", &[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 1840 +fn c1822_l1840_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1822_l1840_action_invoke"); + let result = instance.call("min", &[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 1841 +fn c1823_l1841_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1823_l1841_action_invoke"); + let result = instance.call("min", &[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 1842 +fn c1824_l1842_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1824_l1842_action_invoke"); + let result = instance.call("min", &[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 1843 +fn c1825_l1843_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1825_l1843_action_invoke"); + let result = instance.call("min", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1844 +fn c1826_l1844_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1826_l1844_action_invoke"); + let result = instance.call("min", &[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 1845 +fn c1827_l1845_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1827_l1845_action_invoke"); + let result = instance.call("min", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1846 +fn c1828_l1846_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1828_l1846_action_invoke"); + let result = instance.call("min", &[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 1847 +fn c1829_l1847_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1829_l1847_action_invoke"); + let result = instance.call("min", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1848 +fn c1830_l1848_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1830_l1848_action_invoke"); + let result = instance.call("min", &[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 1849 +fn c1831_l1849_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1831_l1849_action_invoke"); + let result = instance.call("min", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1850 +fn c1832_l1850_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1832_l1850_action_invoke"); + let result = instance.call("min", &[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 1851 +fn c1833_l1851_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1833_l1851_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1833_l1851_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1852 +fn c1834_l1852_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1834_l1852_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1834_l1852_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1853 +fn c1835_l1853_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1835_l1853_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1835_l1853_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1854 +fn c1836_l1854_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1836_l1854_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1836_l1854_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1855 +fn c1837_l1855_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1837_l1855_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1837_l1855_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1856 +fn c1838_l1856_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1838_l1856_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1838_l1856_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1857 +fn c1839_l1857_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1839_l1857_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1839_l1857_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1858 +fn c1840_l1858_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1840_l1858_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1840_l1858_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1859 +fn c1841_l1859_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1841_l1859_action_invoke"); + let result = instance.call("min", &[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 1860 +fn c1842_l1860_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1842_l1860_action_invoke"); + let result = instance.call("min", &[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 1861 +fn c1843_l1861_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1843_l1861_action_invoke"); + let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1862 +fn c1844_l1862_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1844_l1862_action_invoke"); + let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1863 +fn c1845_l1863_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1845_l1863_action_invoke"); + let result = instance.call("min", &[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 1864 +fn c1846_l1864_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1846_l1864_action_invoke"); + let result = instance.call("min", &[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 1865 +fn c1847_l1865_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1847_l1865_action_invoke"); + let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1866 +fn c1848_l1866_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1848_l1866_action_invoke"); + let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1867 +fn c1849_l1867_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1849_l1867_action_invoke"); + let result = instance.call("min", &[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 1868 +fn c1850_l1868_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1850_l1868_action_invoke"); + let result = instance.call("min", &[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 1869 +fn c1851_l1869_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1851_l1869_action_invoke"); + let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1870 +fn c1852_l1870_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1852_l1870_action_invoke"); + let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1871 +fn c1853_l1871_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1853_l1871_action_invoke"); + let result = instance.call("min", &[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 1872 +fn c1854_l1872_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1854_l1872_action_invoke"); + let result = instance.call("min", &[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 1873 +fn c1855_l1873_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1855_l1873_action_invoke"); + let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1874 +fn c1856_l1874_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1856_l1874_action_invoke"); + let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1875 +fn c1857_l1875_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1857_l1875_action_invoke"); + let result = instance.call("min", &[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 1876 +fn c1858_l1876_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1858_l1876_action_invoke"); + let result = instance.call("min", &[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 1877 +fn c1859_l1877_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1859_l1877_action_invoke"); + let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1878 +fn c1860_l1878_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1860_l1878_action_invoke"); + let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1879 +fn c1861_l1879_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1861_l1879_action_invoke"); + let result = instance.call("min", &[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 1880 +fn c1862_l1880_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1862_l1880_action_invoke"); + let result = instance.call("min", &[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 1881 +fn c1863_l1881_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1863_l1881_action_invoke"); + let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1882 +fn c1864_l1882_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1864_l1882_action_invoke"); + let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1883 +fn c1865_l1883_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1865_l1883_action_invoke"); + let result = instance.call("min", &[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 1884 +fn c1866_l1884_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1866_l1884_action_invoke"); + let result = instance.call("min", &[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 1885 +fn c1867_l1885_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1867_l1885_action_invoke"); + let result = instance.call("min", &[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 1886 +fn c1868_l1886_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1868_l1886_action_invoke"); + let result = instance.call("min", &[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 1887 +fn c1869_l1887_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1869_l1887_action_invoke"); + let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1888 +fn c1870_l1888_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1870_l1888_action_invoke"); + let result = instance.call("min", &[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 1889 +fn c1871_l1889_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1871_l1889_action_invoke"); + let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1890 +fn c1872_l1890_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1872_l1890_action_invoke"); + let result = instance.call("min", &[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 1891 +fn c1873_l1891_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1873_l1891_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1873_l1891_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1892 +fn c1874_l1892_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1874_l1892_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1874_l1892_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1893 +fn c1875_l1893_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1875_l1893_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1875_l1893_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1894 +fn c1876_l1894_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1876_l1894_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1876_l1894_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1895 +fn c1877_l1895_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1877_l1895_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1877_l1895_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1896 +fn c1878_l1896_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1878_l1896_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1878_l1896_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1897 +fn c1879_l1897_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1879_l1897_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1879_l1897_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1898 +fn c1880_l1898_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1880_l1898_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1880_l1898_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1899 +fn c1881_l1899_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1881_l1899_action_invoke"); + let result = instance.call("min", &[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 1900 +fn c1882_l1900_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1882_l1900_action_invoke"); + let result = instance.call("min", &[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 1901 +fn c1883_l1901_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1883_l1901_action_invoke"); + let result = instance.call("min", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1902 +fn c1884_l1902_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1884_l1902_action_invoke"); + let result = instance.call("min", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1903 +fn c1885_l1903_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1885_l1903_action_invoke"); + let result = instance.call("min", &[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 1904 +fn c1886_l1904_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1886_l1904_action_invoke"); + let result = instance.call("min", &[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 1905 +fn c1887_l1905_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1887_l1905_action_invoke"); + let result = instance.call("min", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1906 +fn c1888_l1906_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1888_l1906_action_invoke"); + let result = instance.call("min", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1907 +fn c1889_l1907_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1889_l1907_action_invoke"); + let result = instance.call("min", &[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 1908 +fn c1890_l1908_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1890_l1908_action_invoke"); + let result = instance.call("min", &[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 1909 +fn c1891_l1909_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1891_l1909_action_invoke"); + let result = instance.call("min", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1910 +fn c1892_l1910_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1892_l1910_action_invoke"); + let result = instance.call("min", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1911 +fn c1893_l1911_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1893_l1911_action_invoke"); + let result = instance.call("min", &[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 1912 +fn c1894_l1912_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1894_l1912_action_invoke"); + let result = instance.call("min", &[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 1913 +fn c1895_l1913_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1895_l1913_action_invoke"); + let result = instance.call("min", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1914 +fn c1896_l1914_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1896_l1914_action_invoke"); + let result = instance.call("min", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1915 +fn c1897_l1915_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1897_l1915_action_invoke"); + let result = instance.call("min", &[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 1916 +fn c1898_l1916_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1898_l1916_action_invoke"); + let result = instance.call("min", &[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 1917 +fn c1899_l1917_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1899_l1917_action_invoke"); + let result = instance.call("min", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1918 +fn c1900_l1918_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1900_l1918_action_invoke"); + let result = instance.call("min", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1919 +fn c1901_l1919_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1901_l1919_action_invoke"); + let result = instance.call("min", &[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 1920 +fn c1902_l1920_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1902_l1920_action_invoke"); + let result = instance.call("min", &[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 1921 +fn c1903_l1921_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1903_l1921_action_invoke"); + let result = instance.call("min", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1922 +fn c1904_l1922_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1904_l1922_action_invoke"); + let result = instance.call("min", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1923 +fn c1905_l1923_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1905_l1923_action_invoke"); + let result = instance.call("min", &[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 1924 +fn c1906_l1924_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1906_l1924_action_invoke"); + let result = instance.call("min", &[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 1925 +fn c1907_l1925_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1907_l1925_action_invoke"); + let result = instance.call("min", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1926 +fn c1908_l1926_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1908_l1926_action_invoke"); + let result = instance.call("min", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1927 +fn c1909_l1927_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1909_l1927_action_invoke"); + let result = instance.call("min", &[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 1928 +fn c1910_l1928_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1910_l1928_action_invoke"); + let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1929 +fn c1911_l1929_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1911_l1929_action_invoke"); + let result = instance.call("min", &[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 1930 +fn c1912_l1930_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1912_l1930_action_invoke"); + let result = instance.call("min", &[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 1931 +fn c1913_l1931_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1913_l1931_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1913_l1931_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1932 +fn c1914_l1932_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1914_l1932_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1914_l1932_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1933 +fn c1915_l1933_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1915_l1933_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1915_l1933_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1934 +fn c1916_l1934_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1916_l1934_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1916_l1934_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1935 +fn c1917_l1935_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1917_l1935_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1917_l1935_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1936 +fn c1918_l1936_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1918_l1936_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1918_l1936_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1937 +fn c1919_l1937_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1919_l1937_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1919_l1937_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1938 +fn c1920_l1938_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1920_l1938_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1920_l1938_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1939 +fn c1921_l1939_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1921_l1939_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c1921_l1939_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1940 +fn c1922_l1940_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1922_l1940_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c1922_l1940_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1941 +fn c1923_l1941_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1923_l1941_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c1923_l1941_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1942 +fn c1924_l1942_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1924_l1942_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c1924_l1942_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1943 +fn c1925_l1943_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1925_l1943_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c1925_l1943_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1944 +fn c1926_l1944_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1926_l1944_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c1926_l1944_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1945 +fn c1927_l1945_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1927_l1945_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c1927_l1945_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1946 +fn c1928_l1946_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1928_l1946_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c1928_l1946_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1947 +fn c1929_l1947_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1929_l1947_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1929_l1947_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1948 +fn c1930_l1948_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1930_l1948_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1930_l1948_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1949 +fn c1931_l1949_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1931_l1949_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1931_l1949_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1950 +fn c1932_l1950_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1932_l1950_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1932_l1950_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1951 +fn c1933_l1951_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1933_l1951_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1933_l1951_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1952 +fn c1934_l1952_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1934_l1952_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1934_l1952_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1953 +fn c1935_l1953_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1935_l1953_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1935_l1953_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1954 +fn c1936_l1954_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1936_l1954_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c1936_l1954_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1955 +fn c1937_l1955_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1937_l1955_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1937_l1955_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1956 +fn c1938_l1956_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1938_l1956_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1938_l1956_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1957 +fn c1939_l1957_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1939_l1957_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1939_l1957_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1958 +fn c1940_l1958_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1940_l1958_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1940_l1958_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1959 +fn c1941_l1959_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1941_l1959_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1941_l1959_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1960 +fn c1942_l1960_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1942_l1960_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1942_l1960_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1961 +fn c1943_l1961_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1943_l1961_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1943_l1961_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1962 +fn c1944_l1962_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1944_l1962_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c1944_l1962_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1963 +fn c1945_l1963_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1945_l1963_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c1945_l1963_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1964 +fn c1946_l1964_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1946_l1964_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c1946_l1964_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1965 +fn c1947_l1965_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1947_l1965_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c1947_l1965_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1966 +fn c1948_l1966_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1948_l1966_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c1948_l1966_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1967 +fn c1949_l1967_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1949_l1967_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c1949_l1967_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1968 +fn c1950_l1968_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1950_l1968_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c1950_l1968_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1969 +fn c1951_l1969_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1951_l1969_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c1951_l1969_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1970 +fn c1952_l1970_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1952_l1970_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c1952_l1970_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1971 +fn c1953_l1971_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1953_l1971_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c1953_l1971_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1972 +fn c1954_l1972_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1954_l1972_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c1954_l1972_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1973 +fn c1955_l1973_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1955_l1973_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c1955_l1973_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1974 +fn c1956_l1974_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1956_l1974_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c1956_l1974_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1975 +fn c1957_l1975_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1957_l1975_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c1957_l1975_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1976 +fn c1958_l1976_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1958_l1976_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c1958_l1976_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1977 +fn c1959_l1977_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1959_l1977_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c1959_l1977_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1978 +fn c1960_l1978_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1960_l1978_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c1960_l1978_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1979 +fn c1961_l1979_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1961_l1979_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1961_l1979_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1980 +fn c1962_l1980_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1962_l1980_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1962_l1980_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1981 +fn c1963_l1981_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1963_l1981_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1963_l1981_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1982 +fn c1964_l1982_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1964_l1982_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1964_l1982_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1983 +fn c1965_l1983_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1965_l1983_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1965_l1983_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1984 +fn c1966_l1984_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1966_l1984_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1966_l1984_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1985 +fn c1967_l1985_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1967_l1985_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1967_l1985_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1986 +fn c1968_l1986_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1968_l1986_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c1968_l1986_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1987 +fn c1969_l1987_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1969_l1987_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1969_l1987_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1988 +fn c1970_l1988_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1970_l1988_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1970_l1988_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1989 +fn c1971_l1989_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1971_l1989_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1971_l1989_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1990 +fn c1972_l1990_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1972_l1990_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1972_l1990_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1991 +fn c1973_l1991_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1973_l1991_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1973_l1991_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1992 +fn c1974_l1992_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1974_l1992_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1974_l1992_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1993 +fn c1975_l1993_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1975_l1993_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1975_l1993_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1994 +fn c1976_l1994_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1976_l1994_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c1976_l1994_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1995 +fn c1977_l1995_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1977_l1995_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1977_l1995_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1996 +fn c1978_l1996_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1978_l1996_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1978_l1996_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1997 +fn c1979_l1997_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1979_l1997_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c1979_l1997_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1998 +fn c1980_l1998_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1980_l1998_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c1980_l1998_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1999 +fn c1981_l1999_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1981_l1999_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1981_l1999_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2000 +fn c1982_l2000_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1982_l2000_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1982_l2000_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2001 +fn c1983_l2001_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1983_l2001_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c1983_l2001_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2002 +fn c1984_l2002_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1984_l2002_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c1984_l2002_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2003 +fn c1985_l2003_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1985_l2003_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1985_l2003_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2004 +fn c1986_l2004_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1986_l2004_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1986_l2004_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2005 +fn c1987_l2005_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1987_l2005_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1987_l2005_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2006 +fn c1988_l2006_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1988_l2006_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1988_l2006_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2007 +fn c1989_l2007_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1989_l2007_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1989_l2007_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2008 +fn c1990_l2008_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1990_l2008_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1990_l2008_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2009 +fn c1991_l2009_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1991_l2009_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1991_l2009_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2010 +fn c1992_l2010_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1992_l2010_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1992_l2010_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2011 +fn c1993_l2011_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1993_l2011_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1993_l2011_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2012 +fn c1994_l2012_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1994_l2012_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c1994_l2012_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2013 +fn c1995_l2013_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1995_l2013_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1995_l2013_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2014 +fn c1996_l2014_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1996_l2014_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c1996_l2014_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2015 +fn c1997_l2015_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1997_l2015_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1997_l2015_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2016 +fn c1998_l2016_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1998_l2016_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c1998_l2016_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2017 +fn c1999_l2017_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1999_l2017_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c1999_l2017_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2018 +fn c2000_l2018_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2000_l2018_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2000_l2018_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2019 +fn c2001_l2019_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2001_l2019_action_invoke"); + let result = instance.call("max", &[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 2020 +fn c2002_l2020_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2002_l2020_action_invoke"); + let result = instance.call("max", &[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 2021 +fn c2003_l2021_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2003_l2021_action_invoke"); + let result = instance.call("max", &[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 2022 +fn c2004_l2022_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2004_l2022_action_invoke"); + let result = instance.call("max", &[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 2023 +fn c2005_l2023_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2005_l2023_action_invoke"); + let result = instance.call("max", &[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 2024 +fn c2006_l2024_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2006_l2024_action_invoke"); + let result = instance.call("max", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2025 +fn c2007_l2025_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2007_l2025_action_invoke"); + let result = instance.call("max", &[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 2026 +fn c2008_l2026_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2008_l2026_action_invoke"); + let result = instance.call("max", &[Value::F32((0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2027 +fn c2009_l2027_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2009_l2027_action_invoke"); + let result = instance.call("max", &[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 2028 +fn c2010_l2028_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2010_l2028_action_invoke"); + let result = instance.call("max", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2029 +fn c2011_l2029_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2011_l2029_action_invoke"); + let result = instance.call("max", &[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 2030 +fn c2012_l2030_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2012_l2030_action_invoke"); + let result = instance.call("max", &[Value::F32((0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2031 +fn c2013_l2031_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2013_l2031_action_invoke"); + let result = instance.call("max", &[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 2032 +fn c2014_l2032_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2014_l2032_action_invoke"); + let result = instance.call("max", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2033 +fn c2015_l2033_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2015_l2033_action_invoke"); + let result = instance.call("max", &[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 2034 +fn c2016_l2034_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2016_l2034_action_invoke"); + let result = instance.call("max", &[Value::F32((0.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2035 +fn c2017_l2035_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2017_l2035_action_invoke"); + let result = instance.call("max", &[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 2036 +fn c2018_l2036_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2018_l2036_action_invoke"); + let result = instance.call("max", &[Value::F32((-0.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2037 +fn c2019_l2037_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2019_l2037_action_invoke"); + let result = instance.call("max", &[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 2038 +fn c2020_l2038_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2020_l2038_action_invoke"); + let result = instance.call("max", &[Value::F32((0.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2039 +fn c2021_l2039_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2021_l2039_action_invoke"); + let result = instance.call("max", &[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 2040 +fn c2022_l2040_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2022_l2040_action_invoke"); + let result = instance.call("max", &[Value::F32((-0.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2041 +fn c2023_l2041_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2023_l2041_action_invoke"); + let result = instance.call("max", &[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 2042 +fn c2024_l2042_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2024_l2042_action_invoke"); + let result = instance.call("max", &[Value::F32((0.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2043 +fn c2025_l2043_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2025_l2043_action_invoke"); + let result = instance.call("max", &[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 2044 +fn c2026_l2044_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2026_l2044_action_invoke"); + let result = instance.call("max", &[Value::F32((-0.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2045 +fn c2027_l2045_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2027_l2045_action_invoke"); + let result = instance.call("max", &[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 2046 +fn c2028_l2046_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2028_l2046_action_invoke"); + let result = instance.call("max", &[Value::F32((0.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2047 +fn c2029_l2047_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2029_l2047_action_invoke"); + let result = instance.call("max", &[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 2048 +fn c2030_l2048_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2030_l2048_action_invoke"); + let result = instance.call("max", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2049 +fn c2031_l2049_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2031_l2049_action_invoke"); + let result = instance.call("max", &[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 2050 +fn c2032_l2050_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2032_l2050_action_invoke"); + let result = instance.call("max", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2051 +fn c2033_l2051_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2033_l2051_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2033_l2051_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2052 +fn c2034_l2052_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2034_l2052_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2034_l2052_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2053 +fn c2035_l2053_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2035_l2053_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2035_l2053_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2054 +fn c2036_l2054_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2036_l2054_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2036_l2054_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2055 +fn c2037_l2055_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2037_l2055_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2037_l2055_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2056 +fn c2038_l2056_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2038_l2056_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2038_l2056_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2057 +fn c2039_l2057_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2039_l2057_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2039_l2057_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2058 +fn c2040_l2058_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2040_l2058_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2040_l2058_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2059 +fn c2041_l2059_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2041_l2059_action_invoke"); + let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2060 +fn c2042_l2060_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2042_l2060_action_invoke"); + let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2061 +fn c2043_l2061_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2043_l2061_action_invoke"); + let result = instance.call("max", &[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 2062 +fn c2044_l2062_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2044_l2062_action_invoke"); + let result = instance.call("max", &[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 2063 +fn c2045_l2063_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2045_l2063_action_invoke"); + let result = instance.call("max", &[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 2064 +fn c2046_l2064_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2046_l2064_action_invoke"); + let result = instance.call("max", &[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 2065 +fn c2047_l2065_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2047_l2065_action_invoke"); + let result = instance.call("max", &[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 2066 +fn c2048_l2066_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2048_l2066_action_invoke"); + let result = instance.call("max", &[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 2067 +fn c2049_l2067_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2049_l2067_action_invoke"); + let result = instance.call("max", &[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 2068 +fn c2050_l2068_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2050_l2068_action_invoke"); + let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2069 +fn c2051_l2069_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2051_l2069_action_invoke"); + let result = instance.call("max", &[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 2070 +fn c2052_l2070_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2052_l2070_action_invoke"); + let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2071 +fn c2053_l2071_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2053_l2071_action_invoke"); + let result = instance.call("max", &[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 2072 +fn c2054_l2072_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2054_l2072_action_invoke"); + let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2073 +fn c2055_l2073_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2055_l2073_action_invoke"); + let result = instance.call("max", &[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 2074 +fn c2056_l2074_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2056_l2074_action_invoke"); + let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2075 +fn c2057_l2075_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2057_l2075_action_invoke"); + let result = instance.call("max", &[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 2076 +fn c2058_l2076_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2058_l2076_action_invoke"); + let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2077 +fn c2059_l2077_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2059_l2077_action_invoke"); + let result = instance.call("max", &[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 2078 +fn c2060_l2078_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2060_l2078_action_invoke"); + let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2079 +fn c2061_l2079_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2061_l2079_action_invoke"); + let result = instance.call("max", &[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 2080 +fn c2062_l2080_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2062_l2080_action_invoke"); + let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2081 +fn c2063_l2081_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2063_l2081_action_invoke"); + let result = instance.call("max", &[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 2082 +fn c2064_l2082_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2064_l2082_action_invoke"); + let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2083 +fn c2065_l2083_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2065_l2083_action_invoke"); + let result = instance.call("max", &[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 2084 +fn c2066_l2084_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2066_l2084_action_invoke"); + let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2085 +fn c2067_l2085_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2067_l2085_action_invoke"); + let result = instance.call("max", &[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 2086 +fn c2068_l2086_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2068_l2086_action_invoke"); + let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2087 +fn c2069_l2087_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2069_l2087_action_invoke"); + let result = instance.call("max", &[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 2088 +fn c2070_l2088_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2070_l2088_action_invoke"); + let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2089 +fn c2071_l2089_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2071_l2089_action_invoke"); + let result = instance.call("max", &[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 2090 +fn c2072_l2090_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2072_l2090_action_invoke"); + let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2091 +fn c2073_l2091_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2073_l2091_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2073_l2091_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2092 +fn c2074_l2092_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2074_l2092_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2074_l2092_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2093 +fn c2075_l2093_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2075_l2093_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2075_l2093_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2094 +fn c2076_l2094_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2076_l2094_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2076_l2094_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2095 +fn c2077_l2095_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2077_l2095_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2077_l2095_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2096 +fn c2078_l2096_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2078_l2096_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2078_l2096_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2097 +fn c2079_l2097_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2079_l2097_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2079_l2097_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2098 +fn c2080_l2098_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2080_l2098_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2080_l2098_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2099 +fn c2081_l2099_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2081_l2099_action_invoke"); + let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2100 +fn c2082_l2100_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2082_l2100_action_invoke"); + let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2101 +fn c2083_l2101_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2083_l2101_action_invoke"); + let result = instance.call("max", &[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 2102 +fn c2084_l2102_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2084_l2102_action_invoke"); + let result = instance.call("max", &[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 2103 +fn c2085_l2103_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2085_l2103_action_invoke"); + let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2104 +fn c2086_l2104_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2086_l2104_action_invoke"); + let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2105 +fn c2087_l2105_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2087_l2105_action_invoke"); + let result = instance.call("max", &[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 2106 +fn c2088_l2106_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2088_l2106_action_invoke"); + let result = instance.call("max", &[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 2107 +fn c2089_l2107_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2089_l2107_action_invoke"); + let result = instance.call("max", &[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 2108 +fn c2090_l2108_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2090_l2108_action_invoke"); + let result = instance.call("max", &[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 2109 +fn c2091_l2109_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2091_l2109_action_invoke"); + let result = instance.call("max", &[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 2110 +fn c2092_l2110_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2092_l2110_action_invoke"); + let result = instance.call("max", &[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 2111 +fn c2093_l2111_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2093_l2111_action_invoke"); + let result = instance.call("max", &[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 2112 +fn c2094_l2112_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2094_l2112_action_invoke"); + let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2113 +fn c2095_l2113_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2095_l2113_action_invoke"); + let result = instance.call("max", &[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 2114 +fn c2096_l2114_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2096_l2114_action_invoke"); + let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2115 +fn c2097_l2115_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2097_l2115_action_invoke"); + let result = instance.call("max", &[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 2116 +fn c2098_l2116_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2098_l2116_action_invoke"); + let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2117 +fn c2099_l2117_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2099_l2117_action_invoke"); + let result = instance.call("max", &[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 2118 +fn c2100_l2118_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2100_l2118_action_invoke"); + let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2119 +fn c2101_l2119_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2101_l2119_action_invoke"); + let result = instance.call("max", &[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 2120 +fn c2102_l2120_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2102_l2120_action_invoke"); + let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2121 +fn c2103_l2121_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2103_l2121_action_invoke"); + let result = instance.call("max", &[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 2122 +fn c2104_l2122_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2104_l2122_action_invoke"); + let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2123 +fn c2105_l2123_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2105_l2123_action_invoke"); + let result = instance.call("max", &[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 2124 +fn c2106_l2124_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2106_l2124_action_invoke"); + let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2125 +fn c2107_l2125_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2107_l2125_action_invoke"); + let result = instance.call("max", &[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 2126 +fn c2108_l2126_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2108_l2126_action_invoke"); + let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2127 +fn c2109_l2127_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2109_l2127_action_invoke"); + let result = instance.call("max", &[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 2128 +fn c2110_l2128_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2110_l2128_action_invoke"); + let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2129 +fn c2111_l2129_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2111_l2129_action_invoke"); + let result = instance.call("max", &[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 2130 +fn c2112_l2130_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2112_l2130_action_invoke"); + let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2131 +fn c2113_l2131_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2113_l2131_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2113_l2131_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2132 +fn c2114_l2132_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2114_l2132_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2114_l2132_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2133 +fn c2115_l2133_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2115_l2133_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2115_l2133_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2134 +fn c2116_l2134_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2116_l2134_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2116_l2134_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2135 +fn c2117_l2135_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2117_l2135_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2117_l2135_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2136 +fn c2118_l2136_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2118_l2136_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2118_l2136_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2137 +fn c2119_l2137_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2119_l2137_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2119_l2137_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2138 +fn c2120_l2138_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2120_l2138_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2120_l2138_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2139 +fn c2121_l2139_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2121_l2139_action_invoke"); + let result = instance.call("max", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2140 +fn c2122_l2140_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2122_l2140_action_invoke"); + let result = instance.call("max", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2141 +fn c2123_l2141_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2123_l2141_action_invoke"); + let result = instance.call("max", &[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 2142 +fn c2124_l2142_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2124_l2142_action_invoke"); + let result = instance.call("max", &[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 2143 +fn c2125_l2143_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2125_l2143_action_invoke"); + let result = instance.call("max", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2144 +fn c2126_l2144_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2126_l2144_action_invoke"); + let result = instance.call("max", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2145 +fn c2127_l2145_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2127_l2145_action_invoke"); + let result = instance.call("max", &[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 2146 +fn c2128_l2146_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2128_l2146_action_invoke"); + let result = instance.call("max", &[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 2147 +fn c2129_l2147_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2129_l2147_action_invoke"); + let result = instance.call("max", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2148 +fn c2130_l2148_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2130_l2148_action_invoke"); + let result = instance.call("max", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2149 +fn c2131_l2149_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2131_l2149_action_invoke"); + let result = instance.call("max", &[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 2150 +fn c2132_l2150_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2132_l2150_action_invoke"); + let result = instance.call("max", &[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 2151 +fn c2133_l2151_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2133_l2151_action_invoke"); + let result = instance.call("max", &[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 2152 +fn c2134_l2152_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2134_l2152_action_invoke"); + let result = instance.call("max", &[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 2153 +fn c2135_l2153_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2135_l2153_action_invoke"); + let result = instance.call("max", &[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 2154 +fn c2136_l2154_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2136_l2154_action_invoke"); + let result = instance.call("max", &[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 2155 +fn c2137_l2155_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2137_l2155_action_invoke"); + let result = instance.call("max", &[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 2156 +fn c2138_l2156_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2138_l2156_action_invoke"); + let result = instance.call("max", &[Value::F32((-0.5f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2157 +fn c2139_l2157_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2139_l2157_action_invoke"); + let result = instance.call("max", &[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 2158 +fn c2140_l2158_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2140_l2158_action_invoke"); + let result = instance.call("max", &[Value::F32((0.5f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2159 +fn c2141_l2159_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2141_l2159_action_invoke"); + let result = instance.call("max", &[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 2160 +fn c2142_l2160_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2142_l2160_action_invoke"); + let result = instance.call("max", &[Value::F32((-0.5f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2161 +fn c2143_l2161_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2143_l2161_action_invoke"); + let result = instance.call("max", &[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 2162 +fn c2144_l2162_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2144_l2162_action_invoke"); + let result = instance.call("max", &[Value::F32((0.5f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2163 +fn c2145_l2163_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2145_l2163_action_invoke"); + let result = instance.call("max", &[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 2164 +fn c2146_l2164_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2146_l2164_action_invoke"); + let result = instance.call("max", &[Value::F32((-0.5f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2165 +fn c2147_l2165_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2147_l2165_action_invoke"); + let result = instance.call("max", &[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 2166 +fn c2148_l2166_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2148_l2166_action_invoke"); + let result = instance.call("max", &[Value::F32((0.5f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2167 +fn c2149_l2167_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2149_l2167_action_invoke"); + let result = instance.call("max", &[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 2168 +fn c2150_l2168_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2150_l2168_action_invoke"); + let result = instance.call("max", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2169 +fn c2151_l2169_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2151_l2169_action_invoke"); + let result = instance.call("max", &[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 2170 +fn c2152_l2170_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2152_l2170_action_invoke"); + let result = instance.call("max", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2171 +fn c2153_l2171_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2153_l2171_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2153_l2171_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2172 +fn c2154_l2172_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2154_l2172_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2154_l2172_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2173 +fn c2155_l2173_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2155_l2173_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2155_l2173_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2174 +fn c2156_l2174_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2156_l2174_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2156_l2174_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2175 +fn c2157_l2175_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2157_l2175_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2157_l2175_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2176 +fn c2158_l2176_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2158_l2176_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2158_l2176_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2177 +fn c2159_l2177_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2159_l2177_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2159_l2177_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2178 +fn c2160_l2178_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2160_l2178_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2160_l2178_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2179 +fn c2161_l2179_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2161_l2179_action_invoke"); + let result = instance.call("max", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2180 +fn c2162_l2180_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2162_l2180_action_invoke"); + let result = instance.call("max", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2181 +fn c2163_l2181_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2163_l2181_action_invoke"); + let result = instance.call("max", &[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 2182 +fn c2164_l2182_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2164_l2182_action_invoke"); + let result = instance.call("max", &[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 2183 +fn c2165_l2183_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2165_l2183_action_invoke"); + let result = instance.call("max", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2184 +fn c2166_l2184_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2166_l2184_action_invoke"); + let result = instance.call("max", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2185 +fn c2167_l2185_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2167_l2185_action_invoke"); + let result = instance.call("max", &[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 2186 +fn c2168_l2186_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2168_l2186_action_invoke"); + let result = instance.call("max", &[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 2187 +fn c2169_l2187_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2169_l2187_action_invoke"); + let result = instance.call("max", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2188 +fn c2170_l2188_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2170_l2188_action_invoke"); + let result = instance.call("max", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2189 +fn c2171_l2189_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2171_l2189_action_invoke"); + let result = instance.call("max", &[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 2190 +fn c2172_l2190_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2172_l2190_action_invoke"); + let result = instance.call("max", &[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 2191 +fn c2173_l2191_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2173_l2191_action_invoke"); + let result = instance.call("max", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2192 +fn c2174_l2192_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2174_l2192_action_invoke"); + let result = instance.call("max", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2193 +fn c2175_l2193_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2175_l2193_action_invoke"); + let result = instance.call("max", &[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 2194 +fn c2176_l2194_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2176_l2194_action_invoke"); + let result = instance.call("max", &[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 2195 +fn c2177_l2195_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2177_l2195_action_invoke"); + let result = instance.call("max", &[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 2196 +fn c2178_l2196_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2178_l2196_action_invoke"); + let result = instance.call("max", &[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 2197 +fn c2179_l2197_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2179_l2197_action_invoke"); + let result = instance.call("max", &[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 2198 +fn c2180_l2198_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2180_l2198_action_invoke"); + let result = instance.call("max", &[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 2199 +fn c2181_l2199_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2181_l2199_action_invoke"); + let result = instance.call("max", &[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 2200 +fn c2182_l2200_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2182_l2200_action_invoke"); + let result = instance.call("max", &[Value::F32((-1.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2201 +fn c2183_l2201_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2183_l2201_action_invoke"); + let result = instance.call("max", &[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 2202 +fn c2184_l2202_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2184_l2202_action_invoke"); + let result = instance.call("max", &[Value::F32((1.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2203 +fn c2185_l2203_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2185_l2203_action_invoke"); + let result = instance.call("max", &[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 2204 +fn c2186_l2204_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2186_l2204_action_invoke"); + let result = instance.call("max", &[Value::F32((-1.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2205 +fn c2187_l2205_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2187_l2205_action_invoke"); + let result = instance.call("max", &[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 2206 +fn c2188_l2206_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2188_l2206_action_invoke"); + let result = instance.call("max", &[Value::F32((1.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2207 +fn c2189_l2207_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2189_l2207_action_invoke"); + let result = instance.call("max", &[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 2208 +fn c2190_l2208_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2190_l2208_action_invoke"); + let result = instance.call("max", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2209 +fn c2191_l2209_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2191_l2209_action_invoke"); + let result = instance.call("max", &[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 2210 +fn c2192_l2210_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2192_l2210_action_invoke"); + let result = instance.call("max", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2211 +fn c2193_l2211_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2193_l2211_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2193_l2211_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2212 +fn c2194_l2212_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2194_l2212_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2194_l2212_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2213 +fn c2195_l2213_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2195_l2213_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2195_l2213_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2214 +fn c2196_l2214_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2196_l2214_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2196_l2214_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2215 +fn c2197_l2215_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2197_l2215_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2197_l2215_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2216 +fn c2198_l2216_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2198_l2216_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2198_l2216_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2217 +fn c2199_l2217_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2199_l2217_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2199_l2217_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2218 +fn c2200_l2218_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2200_l2218_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2200_l2218_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2219 +fn c2201_l2219_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2201_l2219_action_invoke"); + let result = instance.call("max", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2220 +fn c2202_l2220_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2202_l2220_action_invoke"); + let result = instance.call("max", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2221 +fn c2203_l2221_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2203_l2221_action_invoke"); + let result = instance.call("max", &[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 2222 +fn c2204_l2222_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2204_l2222_action_invoke"); + let result = instance.call("max", &[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 2223 +fn c2205_l2223_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2205_l2223_action_invoke"); + let result = instance.call("max", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2224 +fn c2206_l2224_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2206_l2224_action_invoke"); + let result = instance.call("max", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2225 +fn c2207_l2225_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2207_l2225_action_invoke"); + let result = instance.call("max", &[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 2226 +fn c2208_l2226_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2208_l2226_action_invoke"); + let result = instance.call("max", &[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 2227 +fn c2209_l2227_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2209_l2227_action_invoke"); + let result = instance.call("max", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2228 +fn c2210_l2228_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2210_l2228_action_invoke"); + let result = instance.call("max", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2229 +fn c2211_l2229_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2211_l2229_action_invoke"); + let result = instance.call("max", &[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 2230 +fn c2212_l2230_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2212_l2230_action_invoke"); + let result = instance.call("max", &[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 2231 +fn c2213_l2231_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2213_l2231_action_invoke"); + let result = instance.call("max", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2232 +fn c2214_l2232_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2214_l2232_action_invoke"); + let result = instance.call("max", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2233 +fn c2215_l2233_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2215_l2233_action_invoke"); + let result = instance.call("max", &[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 2234 +fn c2216_l2234_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2216_l2234_action_invoke"); + let result = instance.call("max", &[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 2235 +fn c2217_l2235_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2217_l2235_action_invoke"); + let result = instance.call("max", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2236 +fn c2218_l2236_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2218_l2236_action_invoke"); + let result = instance.call("max", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2237 +fn c2219_l2237_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2219_l2237_action_invoke"); + let result = instance.call("max", &[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 2238 +fn c2220_l2238_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2220_l2238_action_invoke"); + let result = instance.call("max", &[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 2239 +fn c2221_l2239_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2221_l2239_action_invoke"); + let result = instance.call("max", &[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 2240 +fn c2222_l2240_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2222_l2240_action_invoke"); + let result = instance.call("max", &[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 2241 +fn c2223_l2241_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2223_l2241_action_invoke"); + let result = instance.call("max", &[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 2242 +fn c2224_l2242_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2224_l2242_action_invoke"); + let result = instance.call("max", &[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 2243 +fn c2225_l2243_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2225_l2243_action_invoke"); + let result = instance.call("max", &[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 2244 +fn c2226_l2244_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2226_l2244_action_invoke"); + let result = instance.call("max", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2245 +fn c2227_l2245_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2227_l2245_action_invoke"); + let result = instance.call("max", &[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 2246 +fn c2228_l2246_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2228_l2246_action_invoke"); + let result = instance.call("max", &[Value::F32((6.2831855f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2247 +fn c2229_l2247_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2229_l2247_action_invoke"); + let result = instance.call("max", &[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 2248 +fn c2230_l2248_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2230_l2248_action_invoke"); + let result = instance.call("max", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2249 +fn c2231_l2249_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2231_l2249_action_invoke"); + let result = instance.call("max", &[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 2250 +fn c2232_l2250_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2232_l2250_action_invoke"); + let result = instance.call("max", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2251 +fn c2233_l2251_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2233_l2251_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2233_l2251_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2252 +fn c2234_l2252_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2234_l2252_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2234_l2252_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2253 +fn c2235_l2253_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2235_l2253_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2235_l2253_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2254 +fn c2236_l2254_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2236_l2254_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2236_l2254_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2255 +fn c2237_l2255_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2237_l2255_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2237_l2255_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2256 +fn c2238_l2256_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2238_l2256_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2238_l2256_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2257 +fn c2239_l2257_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2239_l2257_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2239_l2257_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2258 +fn c2240_l2258_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2240_l2258_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2240_l2258_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2259 +fn c2241_l2259_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2241_l2259_action_invoke"); + let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2260 +fn c2242_l2260_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2242_l2260_action_invoke"); + let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2261 +fn c2243_l2261_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2243_l2261_action_invoke"); + let result = instance.call("max", &[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 2262 +fn c2244_l2262_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2244_l2262_action_invoke"); + let result = instance.call("max", &[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 2263 +fn c2245_l2263_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2245_l2263_action_invoke"); + let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2264 +fn c2246_l2264_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2246_l2264_action_invoke"); + let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2265 +fn c2247_l2265_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2247_l2265_action_invoke"); + let result = instance.call("max", &[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 2266 +fn c2248_l2266_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2248_l2266_action_invoke"); + let result = instance.call("max", &[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 2267 +fn c2249_l2267_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2249_l2267_action_invoke"); + let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2268 +fn c2250_l2268_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2250_l2268_action_invoke"); + let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2269 +fn c2251_l2269_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2251_l2269_action_invoke"); + let result = instance.call("max", &[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 2270 +fn c2252_l2270_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2252_l2270_action_invoke"); + let result = instance.call("max", &[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 2271 +fn c2253_l2271_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2253_l2271_action_invoke"); + let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2272 +fn c2254_l2272_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2254_l2272_action_invoke"); + let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2273 +fn c2255_l2273_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2255_l2273_action_invoke"); + let result = instance.call("max", &[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 2274 +fn c2256_l2274_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2256_l2274_action_invoke"); + let result = instance.call("max", &[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 2275 +fn c2257_l2275_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2257_l2275_action_invoke"); + let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2276 +fn c2258_l2276_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2258_l2276_action_invoke"); + let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2277 +fn c2259_l2277_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2259_l2277_action_invoke"); + let result = instance.call("max", &[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 2278 +fn c2260_l2278_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2260_l2278_action_invoke"); + let result = instance.call("max", &[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 2279 +fn c2261_l2279_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2261_l2279_action_invoke"); + let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2280 +fn c2262_l2280_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2262_l2280_action_invoke"); + let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2281 +fn c2263_l2281_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2263_l2281_action_invoke"); + let result = instance.call("max", &[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 2282 +fn c2264_l2282_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2264_l2282_action_invoke"); + let result = instance.call("max", &[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 2283 +fn c2265_l2283_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2265_l2283_action_invoke"); + let result = instance.call("max", &[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 2284 +fn c2266_l2284_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2266_l2284_action_invoke"); + let result = instance.call("max", &[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 2285 +fn c2267_l2285_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2267_l2285_action_invoke"); + let result = instance.call("max", &[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 2286 +fn c2268_l2286_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2268_l2286_action_invoke"); + let result = instance.call("max", &[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 2287 +fn c2269_l2287_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2269_l2287_action_invoke"); + let result = instance.call("max", &[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 2288 +fn c2270_l2288_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2270_l2288_action_invoke"); + let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2289 +fn c2271_l2289_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2271_l2289_action_invoke"); + let result = instance.call("max", &[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 2290 +fn c2272_l2290_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2272_l2290_action_invoke"); + let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2291 +fn c2273_l2291_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2273_l2291_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2273_l2291_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2292 +fn c2274_l2292_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2274_l2292_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2274_l2292_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2293 +fn c2275_l2293_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2275_l2293_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2275_l2293_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2294 +fn c2276_l2294_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2276_l2294_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2276_l2294_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2295 +fn c2277_l2295_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2277_l2295_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2277_l2295_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2296 +fn c2278_l2296_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2278_l2296_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2278_l2296_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2297 +fn c2279_l2297_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2279_l2297_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2279_l2297_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2298 +fn c2280_l2298_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2280_l2298_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2280_l2298_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2299 +fn c2281_l2299_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2281_l2299_action_invoke"); + let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2300 +fn c2282_l2300_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2282_l2300_action_invoke"); + let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2301 +fn c2283_l2301_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2283_l2301_action_invoke"); + let result = instance.call("max", &[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 2302 +fn c2284_l2302_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2284_l2302_action_invoke"); + let result = instance.call("max", &[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 2303 +fn c2285_l2303_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2285_l2303_action_invoke"); + let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2304 +fn c2286_l2304_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2286_l2304_action_invoke"); + let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2305 +fn c2287_l2305_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2287_l2305_action_invoke"); + let result = instance.call("max", &[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 2306 +fn c2288_l2306_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2288_l2306_action_invoke"); + let result = instance.call("max", &[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 2307 +fn c2289_l2307_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2289_l2307_action_invoke"); + let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2308 +fn c2290_l2308_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2290_l2308_action_invoke"); + let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2309 +fn c2291_l2309_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2291_l2309_action_invoke"); + let result = instance.call("max", &[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 2310 +fn c2292_l2310_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2292_l2310_action_invoke"); + let result = instance.call("max", &[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 2311 +fn c2293_l2311_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2293_l2311_action_invoke"); + let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2312 +fn c2294_l2312_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2294_l2312_action_invoke"); + let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2313 +fn c2295_l2313_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2295_l2313_action_invoke"); + let result = instance.call("max", &[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 2314 +fn c2296_l2314_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2296_l2314_action_invoke"); + let result = instance.call("max", &[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 2315 +fn c2297_l2315_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2297_l2315_action_invoke"); + let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2316 +fn c2298_l2316_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2298_l2316_action_invoke"); + let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2317 +fn c2299_l2317_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2299_l2317_action_invoke"); + let result = instance.call("max", &[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 2318 +fn c2300_l2318_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2300_l2318_action_invoke"); + let result = instance.call("max", &[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 2319 +fn c2301_l2319_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2301_l2319_action_invoke"); + let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2320 +fn c2302_l2320_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2302_l2320_action_invoke"); + let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2321 +fn c2303_l2321_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2303_l2321_action_invoke"); + let result = instance.call("max", &[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 2322 +fn c2304_l2322_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2304_l2322_action_invoke"); + let result = instance.call("max", &[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 2323 +fn c2305_l2323_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2305_l2323_action_invoke"); + let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2324 +fn c2306_l2324_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2306_l2324_action_invoke"); + let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2325 +fn c2307_l2325_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2307_l2325_action_invoke"); + let result = instance.call("max", &[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 2326 +fn c2308_l2326_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2308_l2326_action_invoke"); + let result = instance.call("max", &[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 2327 +fn c2309_l2327_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2309_l2327_action_invoke"); + let result = instance.call("max", &[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 2328 +fn c2310_l2328_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2310_l2328_action_invoke"); + let result = instance.call("max", &[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 2329 +fn c2311_l2329_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2311_l2329_action_invoke"); + let result = instance.call("max", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2330 +fn c2312_l2330_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2312_l2330_action_invoke"); + let result = instance.call("max", &[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 2331 +fn c2313_l2331_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2313_l2331_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2313_l2331_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2332 +fn c2314_l2332_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2314_l2332_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2314_l2332_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2333 +fn c2315_l2333_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2315_l2333_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2315_l2333_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2334 +fn c2316_l2334_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2316_l2334_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2316_l2334_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2335 +fn c2317_l2335_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2317_l2335_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2317_l2335_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2336 +fn c2318_l2336_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2318_l2336_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2318_l2336_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2337 +fn c2319_l2337_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2319_l2337_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2319_l2337_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2338 +fn c2320_l2338_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2320_l2338_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2320_l2338_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2339 +fn c2321_l2339_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2321_l2339_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c2321_l2339_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2340 +fn c2322_l2340_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2322_l2340_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c2322_l2340_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2341 +fn c2323_l2341_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2323_l2341_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c2323_l2341_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2342 +fn c2324_l2342_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2324_l2342_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c2324_l2342_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2343 +fn c2325_l2343_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2325_l2343_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c2325_l2343_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2344 +fn c2326_l2344_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2326_l2344_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c2326_l2344_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2345 +fn c2327_l2345_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2327_l2345_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c2327_l2345_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2346 +fn c2328_l2346_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2328_l2346_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c2328_l2346_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2347 +fn c2329_l2347_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2329_l2347_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c2329_l2347_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2348 +fn c2330_l2348_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2330_l2348_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c2330_l2348_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2349 +fn c2331_l2349_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2331_l2349_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c2331_l2349_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2350 +fn c2332_l2350_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2332_l2350_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c2332_l2350_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2351 +fn c2333_l2351_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2333_l2351_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c2333_l2351_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2352 +fn c2334_l2352_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2334_l2352_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c2334_l2352_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2353 +fn c2335_l2353_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2335_l2353_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c2335_l2353_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2354 +fn c2336_l2354_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2336_l2354_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c2336_l2354_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2355 +fn c2337_l2355_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2337_l2355_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c2337_l2355_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2356 +fn c2338_l2356_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2338_l2356_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c2338_l2356_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2357 +fn c2339_l2357_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2339_l2357_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c2339_l2357_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2358 +fn c2340_l2358_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2340_l2358_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c2340_l2358_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2359 +fn c2341_l2359_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2341_l2359_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c2341_l2359_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2360 +fn c2342_l2360_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2342_l2360_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c2342_l2360_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2361 +fn c2343_l2361_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2343_l2361_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c2343_l2361_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2362 +fn c2344_l2362_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2344_l2362_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c2344_l2362_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2363 +fn c2345_l2363_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2345_l2363_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c2345_l2363_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2364 +fn c2346_l2364_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2346_l2364_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c2346_l2364_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2365 +fn c2347_l2365_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2347_l2365_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c2347_l2365_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2366 +fn c2348_l2366_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2348_l2366_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c2348_l2366_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2367 +fn c2349_l2367_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2349_l2367_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c2349_l2367_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2368 +fn c2350_l2368_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2350_l2368_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c2350_l2368_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2369 +fn c2351_l2369_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2351_l2369_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c2351_l2369_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2370 +fn c2352_l2370_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2352_l2370_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.5f32).to_bits())]).unwrap().expect("Missing result in c2352_l2370_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2371 +fn c2353_l2371_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2353_l2371_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c2353_l2371_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2372 +fn c2354_l2372_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2354_l2372_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c2354_l2372_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2373 +fn c2355_l2373_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2355_l2373_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c2355_l2373_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2374 +fn c2356_l2374_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2356_l2374_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c2356_l2374_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2375 +fn c2357_l2375_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2357_l2375_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c2357_l2375_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2376 +fn c2358_l2376_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2358_l2376_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c2358_l2376_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2377 +fn c2359_l2377_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2359_l2377_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c2359_l2377_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2378 +fn c2360_l2378_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2360_l2378_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((1.0f32).to_bits())]).unwrap().expect("Missing result in c2360_l2378_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2379 +fn c2361_l2379_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2361_l2379_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c2361_l2379_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2380 +fn c2362_l2380_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2362_l2380_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c2362_l2380_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2381 +fn c2363_l2381_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2363_l2381_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c2363_l2381_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2382 +fn c2364_l2382_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2364_l2382_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c2364_l2382_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2383 +fn c2365_l2383_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2365_l2383_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c2365_l2383_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2384 +fn c2366_l2384_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2366_l2384_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c2366_l2384_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2385 +fn c2367_l2385_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2367_l2385_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c2367_l2385_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2386 +fn c2368_l2386_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2368_l2386_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((6.2831855f32).to_bits())]).unwrap().expect("Missing result in c2368_l2386_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2387 +fn c2369_l2387_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2369_l2387_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c2369_l2387_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2388 +fn c2370_l2388_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2370_l2388_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c2370_l2388_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2389 +fn c2371_l2389_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2371_l2389_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c2371_l2389_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2390 +fn c2372_l2390_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2372_l2390_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c2372_l2390_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2391 +fn c2373_l2391_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2373_l2391_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c2373_l2391_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2392 +fn c2374_l2392_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2374_l2392_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c2374_l2392_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2393 +fn c2375_l2393_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2375_l2393_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c2375_l2393_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2394 +fn c2376_l2394_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2376_l2394_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c2376_l2394_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2395 +fn c2377_l2395_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2377_l2395_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c2377_l2395_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2396 +fn c2378_l2396_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2378_l2396_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c2378_l2396_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2397 +fn c2379_l2397_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2379_l2397_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c2379_l2397_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2398 +fn c2380_l2398_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2380_l2398_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c2380_l2398_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2399 +fn c2381_l2399_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2381_l2399_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c2381_l2399_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2400 +fn c2382_l2400_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2382_l2400_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c2382_l2400_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2401 +fn c2383_l2401_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2383_l2401_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c2383_l2401_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2402 +fn c2384_l2402_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2384_l2402_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c2384_l2402_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2403 +fn c2385_l2403_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2385_l2403_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2385_l2403_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2404 +fn c2386_l2404_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2386_l2404_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2386_l2404_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2405 +fn c2387_l2405_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2387_l2405_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2387_l2405_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2406 +fn c2388_l2406_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2388_l2406_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2388_l2406_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2407 +fn c2389_l2407_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2389_l2407_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2389_l2407_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2408 +fn c2390_l2408_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2390_l2408_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2390_l2408_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2409 +fn c2391_l2409_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2391_l2409_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2391_l2409_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2410 +fn c2392_l2410_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2392_l2410_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2392_l2410_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2411 +fn c2393_l2411_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2393_l2411_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2393_l2411_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2412 +fn c2394_l2412_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2394_l2412_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2394_l2412_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2413 +fn c2395_l2413_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2395_l2413_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2395_l2413_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2414 +fn c2396_l2414_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2396_l2414_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2396_l2414_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2415 +fn c2397_l2415_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2397_l2415_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2397_l2415_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2416 +fn c2398_l2416_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2398_l2416_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2398_l2416_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2417 +fn c2399_l2417_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2399_l2417_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2399_l2417_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2418 +fn c2400_l2418_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2400_l2418_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2400_l2418_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2419 +fn c2401_l2419_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2401_l2419_action_invoke"); + let result = instance.call("sqrt", &[Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2420 +fn c2402_l2420_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2402_l2420_action_invoke"); + let result = instance.call("sqrt", &[Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2421 +fn c2403_l2421_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2403_l2421_assert_return_canonical_nan"); + let result = instance.call("sqrt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]).unwrap().expect("Missing result in c2403_l2421_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2422 +fn c2404_l2422_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2404_l2422_action_invoke"); + let result = instance.call("sqrt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000000003743392f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2423 +fn c2405_l2423_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2405_l2423_assert_return_canonical_nan"); + let result = instance.call("sqrt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]).unwrap().expect("Missing result in c2405_l2423_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2424 +fn c2406_l2424_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2406_l2424_action_invoke"); + let result = instance.call("sqrt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000010842022f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2425 +fn c2407_l2425_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2407_l2425_assert_return_canonical_nan"); + let result = instance.call("sqrt", &[Value::F32((-0.5f32).to_bits())]).unwrap().expect("Missing result in c2407_l2425_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2426 +fn c2408_l2426_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2408_l2426_action_invoke"); + let result = instance.call("sqrt", &[Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.70710677f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2427 +fn c2409_l2427_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2409_l2427_assert_return_canonical_nan"); + let result = instance.call("sqrt", &[Value::F32((-1.0f32).to_bits())]).unwrap().expect("Missing result in c2409_l2427_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2428 +fn c2410_l2428_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2410_l2428_action_invoke"); + let result = instance.call("sqrt", &[Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2429 +fn c2411_l2429_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2411_l2429_assert_return_canonical_nan"); + let result = instance.call("sqrt", &[Value::F32((-6.2831855f32).to_bits())]).unwrap().expect("Missing result in c2411_l2429_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2430 +fn c2412_l2430_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2412_l2430_action_invoke"); + let result = instance.call("sqrt", &[Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((2.5066283f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2431 +fn c2413_l2431_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2413_l2431_assert_return_canonical_nan"); + let result = instance.call("sqrt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]).unwrap().expect("Missing result in c2413_l2431_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2432 +fn c2414_l2432_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2414_l2432_action_invoke"); + let result = instance.call("sqrt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((18446743000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2433 +fn c2415_l2433_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2415_l2433_assert_return_canonical_nan"); + let result = instance.call("sqrt", &[Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c2415_l2433_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2434 +fn c2416_l2434_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2416_l2434_action_invoke"); + let result = instance.call("sqrt", &[Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2435 +fn c2417_l2435_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2417_l2435_assert_return_canonical_nan"); + let result = instance.call("sqrt", &[Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2417_l2435_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2436 +fn c2418_l2436_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2418_l2436_assert_return_arithmetic_nan"); + let result = instance.call("sqrt", &[Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2418_l2436_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2437 +fn c2419_l2437_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2419_l2437_assert_return_canonical_nan"); + let result = instance.call("sqrt", &[Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2419_l2437_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2438 +fn c2420_l2438_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2420_l2438_assert_return_arithmetic_nan"); + let result = instance.call("sqrt", &[Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2420_l2438_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2439 +fn c2421_l2439_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2421_l2439_action_invoke"); + let result = instance.call("floor", &[Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2440 +fn c2422_l2440_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2422_l2440_action_invoke"); + let result = instance.call("floor", &[Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2441 +fn c2423_l2441_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2423_l2441_action_invoke"); + let result = instance.call("floor", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2442 +fn c2424_l2442_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2424_l2442_action_invoke"); + let result = instance.call("floor", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2443 +fn c2425_l2443_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2425_l2443_action_invoke"); + let result = instance.call("floor", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2444 +fn c2426_l2444_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2426_l2444_action_invoke"); + let result = instance.call("floor", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2445 +fn c2427_l2445_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2427_l2445_action_invoke"); + let result = instance.call("floor", &[Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2446 +fn c2428_l2446_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2428_l2446_action_invoke"); + let result = instance.call("floor", &[Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2447 +fn c2429_l2447_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2429_l2447_action_invoke"); + let result = instance.call("floor", &[Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2448 +fn c2430_l2448_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2430_l2448_action_invoke"); + let result = instance.call("floor", &[Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2449 +fn c2431_l2449_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2431_l2449_action_invoke"); + let result = instance.call("floor", &[Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-7.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2450 +fn c2432_l2450_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2432_l2450_action_invoke"); + let result = instance.call("floor", &[Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((6.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2451 +fn c2433_l2451_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2433_l2451_action_invoke"); + let result = instance.call("floor", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2452 +fn c2434_l2452_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2434_l2452_action_invoke"); + let result = instance.call("floor", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2453 +fn c2435_l2453_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2435_l2453_action_invoke"); + let result = instance.call("floor", &[Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2454 +fn c2436_l2454_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2436_l2454_action_invoke"); + let result = instance.call("floor", &[Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2455 +fn c2437_l2455_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2437_l2455_assert_return_canonical_nan"); + let result = instance.call("floor", &[Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2437_l2455_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2456 +fn c2438_l2456_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2438_l2456_assert_return_arithmetic_nan"); + let result = instance.call("floor", &[Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2438_l2456_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2457 +fn c2439_l2457_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2439_l2457_assert_return_canonical_nan"); + let result = instance.call("floor", &[Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2439_l2457_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2458 +fn c2440_l2458_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2440_l2458_assert_return_arithmetic_nan"); + let result = instance.call("floor", &[Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2440_l2458_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2459 +fn c2441_l2459_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2441_l2459_action_invoke"); + let result = instance.call("ceil", &[Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2460 +fn c2442_l2460_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2442_l2460_action_invoke"); + let result = instance.call("ceil", &[Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2461 +fn c2443_l2461_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2443_l2461_action_invoke"); + let result = instance.call("ceil", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2462 +fn c2444_l2462_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2444_l2462_action_invoke"); + let result = instance.call("ceil", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2463 +fn c2445_l2463_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2445_l2463_action_invoke"); + let result = instance.call("ceil", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2464 +fn c2446_l2464_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2446_l2464_action_invoke"); + let result = instance.call("ceil", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2465 +fn c2447_l2465_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2447_l2465_action_invoke"); + let result = instance.call("ceil", &[Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2466 +fn c2448_l2466_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2448_l2466_action_invoke"); + let result = instance.call("ceil", &[Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2467 +fn c2449_l2467_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2449_l2467_action_invoke"); + let result = instance.call("ceil", &[Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2468 +fn c2450_l2468_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2450_l2468_action_invoke"); + let result = instance.call("ceil", &[Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2469 +fn c2451_l2469_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2451_l2469_action_invoke"); + let result = instance.call("ceil", &[Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2470 +fn c2452_l2470_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2452_l2470_action_invoke"); + let result = instance.call("ceil", &[Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((7.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2471 +fn c2453_l2471_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2453_l2471_action_invoke"); + let result = instance.call("ceil", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2472 +fn c2454_l2472_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2454_l2472_action_invoke"); + let result = instance.call("ceil", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2473 +fn c2455_l2473_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2455_l2473_action_invoke"); + let result = instance.call("ceil", &[Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2474 +fn c2456_l2474_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2456_l2474_action_invoke"); + let result = instance.call("ceil", &[Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2475 +fn c2457_l2475_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2457_l2475_assert_return_canonical_nan"); + let result = instance.call("ceil", &[Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2457_l2475_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2476 +fn c2458_l2476_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2458_l2476_assert_return_arithmetic_nan"); + let result = instance.call("ceil", &[Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2458_l2476_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2477 +fn c2459_l2477_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2459_l2477_assert_return_canonical_nan"); + let result = instance.call("ceil", &[Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2459_l2477_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2478 +fn c2460_l2478_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2460_l2478_assert_return_arithmetic_nan"); + let result = instance.call("ceil", &[Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2460_l2478_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2479 +fn c2461_l2479_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2461_l2479_action_invoke"); + let result = instance.call("trunc", &[Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2480 +fn c2462_l2480_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2462_l2480_action_invoke"); + let result = instance.call("trunc", &[Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2481 +fn c2463_l2481_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2463_l2481_action_invoke"); + let result = instance.call("trunc", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2482 +fn c2464_l2482_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2464_l2482_action_invoke"); + let result = instance.call("trunc", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2483 +fn c2465_l2483_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2465_l2483_action_invoke"); + let result = instance.call("trunc", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2484 +fn c2466_l2484_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2466_l2484_action_invoke"); + let result = instance.call("trunc", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2485 +fn c2467_l2485_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2467_l2485_action_invoke"); + let result = instance.call("trunc", &[Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2486 +fn c2468_l2486_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2468_l2486_action_invoke"); + let result = instance.call("trunc", &[Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2487 +fn c2469_l2487_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2469_l2487_action_invoke"); + let result = instance.call("trunc", &[Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2488 +fn c2470_l2488_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2470_l2488_action_invoke"); + let result = instance.call("trunc", &[Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2489 +fn c2471_l2489_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2471_l2489_action_invoke"); + let result = instance.call("trunc", &[Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2490 +fn c2472_l2490_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2472_l2490_action_invoke"); + let result = instance.call("trunc", &[Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((6.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2491 +fn c2473_l2491_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2473_l2491_action_invoke"); + let result = instance.call("trunc", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2492 +fn c2474_l2492_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2474_l2492_action_invoke"); + let result = instance.call("trunc", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2493 +fn c2475_l2493_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2475_l2493_action_invoke"); + let result = instance.call("trunc", &[Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2494 +fn c2476_l2494_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2476_l2494_action_invoke"); + let result = instance.call("trunc", &[Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2495 +fn c2477_l2495_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2477_l2495_assert_return_canonical_nan"); + let result = instance.call("trunc", &[Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2477_l2495_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2496 +fn c2478_l2496_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2478_l2496_assert_return_arithmetic_nan"); + let result = instance.call("trunc", &[Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2478_l2496_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2497 +fn c2479_l2497_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2479_l2497_assert_return_canonical_nan"); + let result = instance.call("trunc", &[Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2479_l2497_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2498 +fn c2480_l2498_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2480_l2498_assert_return_arithmetic_nan"); + let result = instance.call("trunc", &[Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2480_l2498_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2499 +fn c2481_l2499_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2481_l2499_action_invoke"); + let result = instance.call("nearest", &[Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2500 +fn c2482_l2500_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2482_l2500_action_invoke"); + let result = instance.call("nearest", &[Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2501 +fn c2483_l2501_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2483_l2501_action_invoke"); + let result = instance.call("nearest", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2502 +fn c2484_l2502_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2484_l2502_action_invoke"); + let result = instance.call("nearest", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2503 +fn c2485_l2503_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2485_l2503_action_invoke"); + let result = instance.call("nearest", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2504 +fn c2486_l2504_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2486_l2504_action_invoke"); + let result = instance.call("nearest", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2505 +fn c2487_l2505_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2487_l2505_action_invoke"); + let result = instance.call("nearest", &[Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2506 +fn c2488_l2506_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2488_l2506_action_invoke"); + let result = instance.call("nearest", &[Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2507 +fn c2489_l2507_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2489_l2507_action_invoke"); + let result = instance.call("nearest", &[Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2508 +fn c2490_l2508_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2490_l2508_action_invoke"); + let result = instance.call("nearest", &[Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2509 +fn c2491_l2509_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2491_l2509_action_invoke"); + let result = instance.call("nearest", &[Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2510 +fn c2492_l2510_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2492_l2510_action_invoke"); + let result = instance.call("nearest", &[Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((6.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2511 +fn c2493_l2511_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2493_l2511_action_invoke"); + let result = instance.call("nearest", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2512 +fn c2494_l2512_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2494_l2512_action_invoke"); + let result = instance.call("nearest", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2513 +fn c2495_l2513_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2495_l2513_action_invoke"); + let result = instance.call("nearest", &[Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2514 +fn c2496_l2514_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2496_l2514_action_invoke"); + let result = instance.call("nearest", &[Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2515 +fn c2497_l2515_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2497_l2515_assert_return_canonical_nan"); + let result = instance.call("nearest", &[Value::F32(f32::from_bits(4290772992) as u32)]).unwrap().expect("Missing result in c2497_l2515_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2516 +fn c2498_l2516_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2498_l2516_assert_return_arithmetic_nan"); + let result = instance.call("nearest", &[Value::F32(f32::from_bits(4288675840) as u32)]).unwrap().expect("Missing result in c2498_l2516_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2517 +fn c2499_l2517_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2499_l2517_assert_return_canonical_nan"); + let result = instance.call("nearest", &[Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c2499_l2517_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2518 +fn c2500_l2518_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2500_l2518_assert_return_arithmetic_nan"); + let result = instance.call("nearest", &[Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c2500_l2518_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l19_action_invoke(&mut instance); + c2_l20_action_invoke(&mut instance); + c3_l21_action_invoke(&mut instance); + c4_l22_action_invoke(&mut instance); + c5_l23_action_invoke(&mut instance); + c6_l24_action_invoke(&mut instance); + c7_l25_action_invoke(&mut instance); + c8_l26_action_invoke(&mut instance); + c9_l27_action_invoke(&mut instance); + c10_l28_action_invoke(&mut instance); + c11_l29_action_invoke(&mut instance); + c12_l30_action_invoke(&mut instance); + c13_l31_action_invoke(&mut instance); + c14_l32_action_invoke(&mut instance); + c15_l33_action_invoke(&mut instance); + c16_l34_action_invoke(&mut instance); + c17_l35_action_invoke(&mut instance); + c18_l36_action_invoke(&mut instance); + c19_l37_action_invoke(&mut instance); + c20_l38_action_invoke(&mut instance); + c21_l39_action_invoke(&mut instance); + c22_l40_action_invoke(&mut instance); + c23_l41_action_invoke(&mut instance); + c24_l42_action_invoke(&mut instance); + c25_l43_action_invoke(&mut instance); + c26_l44_action_invoke(&mut instance); + c27_l45_action_invoke(&mut instance); + c28_l46_action_invoke(&mut instance); + c29_l47_action_invoke(&mut instance); + c30_l48_action_invoke(&mut instance); + c31_l49_action_invoke(&mut instance); + c32_l50_action_invoke(&mut instance); + c33_l51_assert_return_canonical_nan(&mut instance); + c34_l52_assert_return_arithmetic_nan(&mut instance); + c35_l53_assert_return_canonical_nan(&mut instance); + c36_l54_assert_return_arithmetic_nan(&mut instance); + c37_l55_assert_return_canonical_nan(&mut instance); + c38_l56_assert_return_arithmetic_nan(&mut instance); + c39_l57_assert_return_canonical_nan(&mut instance); + c40_l58_assert_return_arithmetic_nan(&mut instance); + c41_l59_action_invoke(&mut instance); + c42_l60_action_invoke(&mut instance); + c43_l61_action_invoke(&mut instance); + c44_l62_action_invoke(&mut instance); + c45_l63_action_invoke(&mut instance); + c46_l64_action_invoke(&mut instance); + c47_l65_action_invoke(&mut instance); + c48_l66_action_invoke(&mut instance); + c49_l67_action_invoke(&mut instance); + c50_l68_action_invoke(&mut instance); + c51_l69_action_invoke(&mut instance); + c52_l70_action_invoke(&mut instance); + c53_l71_action_invoke(&mut instance); + c54_l72_action_invoke(&mut instance); + c55_l73_action_invoke(&mut instance); + c56_l74_action_invoke(&mut instance); + c57_l75_action_invoke(&mut instance); + c58_l76_action_invoke(&mut instance); + c59_l77_action_invoke(&mut instance); + c60_l78_action_invoke(&mut instance); + c61_l79_action_invoke(&mut instance); + c62_l80_action_invoke(&mut instance); + c63_l81_action_invoke(&mut instance); + c64_l82_action_invoke(&mut instance); + c65_l83_action_invoke(&mut instance); + c66_l84_action_invoke(&mut instance); + c67_l85_action_invoke(&mut instance); + c68_l86_action_invoke(&mut instance); + c69_l87_action_invoke(&mut instance); + c70_l88_action_invoke(&mut instance); + c71_l89_action_invoke(&mut instance); + c72_l90_action_invoke(&mut instance); + c73_l91_assert_return_canonical_nan(&mut instance); + c74_l92_assert_return_arithmetic_nan(&mut instance); + c75_l93_assert_return_canonical_nan(&mut instance); + c76_l94_assert_return_arithmetic_nan(&mut instance); + c77_l95_assert_return_canonical_nan(&mut instance); + c78_l96_assert_return_arithmetic_nan(&mut instance); + c79_l97_assert_return_canonical_nan(&mut instance); + c80_l98_assert_return_arithmetic_nan(&mut instance); + c81_l99_action_invoke(&mut instance); + c82_l100_action_invoke(&mut instance); + c83_l101_action_invoke(&mut instance); + c84_l102_action_invoke(&mut instance); + c85_l103_action_invoke(&mut instance); + c86_l104_action_invoke(&mut instance); + c87_l105_action_invoke(&mut instance); + c88_l106_action_invoke(&mut instance); + c89_l107_action_invoke(&mut instance); + c90_l108_action_invoke(&mut instance); + c91_l109_action_invoke(&mut instance); + c92_l110_action_invoke(&mut instance); + c93_l111_action_invoke(&mut instance); + c94_l112_action_invoke(&mut instance); + c95_l113_action_invoke(&mut instance); + c96_l114_action_invoke(&mut instance); + c97_l115_action_invoke(&mut instance); + c98_l116_action_invoke(&mut instance); + c99_l117_action_invoke(&mut instance); + c100_l118_action_invoke(&mut instance); + c101_l119_action_invoke(&mut instance); + c102_l120_action_invoke(&mut instance); + c103_l121_action_invoke(&mut instance); + c104_l122_action_invoke(&mut instance); + c105_l123_action_invoke(&mut instance); + c106_l124_action_invoke(&mut instance); + c107_l125_action_invoke(&mut instance); + c108_l126_action_invoke(&mut instance); + c109_l127_action_invoke(&mut instance); + c110_l128_action_invoke(&mut instance); + c111_l129_action_invoke(&mut instance); + c112_l130_action_invoke(&mut instance); + c113_l131_assert_return_canonical_nan(&mut instance); + c114_l132_assert_return_arithmetic_nan(&mut instance); + c115_l133_assert_return_canonical_nan(&mut instance); + c116_l134_assert_return_arithmetic_nan(&mut instance); + c117_l135_assert_return_canonical_nan(&mut instance); + c118_l136_assert_return_arithmetic_nan(&mut instance); + c119_l137_assert_return_canonical_nan(&mut instance); + c120_l138_assert_return_arithmetic_nan(&mut instance); + c121_l139_action_invoke(&mut instance); + c122_l140_action_invoke(&mut instance); + c123_l141_action_invoke(&mut instance); + c124_l142_action_invoke(&mut instance); + c125_l143_action_invoke(&mut instance); + c126_l144_action_invoke(&mut instance); + c127_l145_action_invoke(&mut instance); + c128_l146_action_invoke(&mut instance); + c129_l147_action_invoke(&mut instance); + c130_l148_action_invoke(&mut instance); + c131_l149_action_invoke(&mut instance); + c132_l150_action_invoke(&mut instance); + c133_l151_action_invoke(&mut instance); + c134_l152_action_invoke(&mut instance); + c135_l153_action_invoke(&mut instance); + c136_l154_action_invoke(&mut instance); + c137_l155_action_invoke(&mut instance); + c138_l156_action_invoke(&mut instance); + c139_l157_action_invoke(&mut instance); + c140_l158_action_invoke(&mut instance); + c141_l159_action_invoke(&mut instance); + c142_l160_action_invoke(&mut instance); + c143_l161_action_invoke(&mut instance); + c144_l162_action_invoke(&mut instance); + c145_l163_action_invoke(&mut instance); + c146_l164_action_invoke(&mut instance); + c147_l165_action_invoke(&mut instance); + c148_l166_action_invoke(&mut instance); + c149_l167_action_invoke(&mut instance); + c150_l168_action_invoke(&mut instance); + c151_l169_action_invoke(&mut instance); + c152_l170_action_invoke(&mut instance); + c153_l171_assert_return_canonical_nan(&mut instance); + c154_l172_assert_return_arithmetic_nan(&mut instance); + c155_l173_assert_return_canonical_nan(&mut instance); + c156_l174_assert_return_arithmetic_nan(&mut instance); + c157_l175_assert_return_canonical_nan(&mut instance); + c158_l176_assert_return_arithmetic_nan(&mut instance); + c159_l177_assert_return_canonical_nan(&mut instance); + c160_l178_assert_return_arithmetic_nan(&mut instance); + c161_l179_action_invoke(&mut instance); + c162_l180_action_invoke(&mut instance); + c163_l181_action_invoke(&mut instance); + c164_l182_action_invoke(&mut instance); + c165_l183_action_invoke(&mut instance); + c166_l184_action_invoke(&mut instance); + c167_l185_action_invoke(&mut instance); + c168_l186_action_invoke(&mut instance); + c169_l187_action_invoke(&mut instance); + c170_l188_action_invoke(&mut instance); + c171_l189_action_invoke(&mut instance); + c172_l190_action_invoke(&mut instance); + c173_l191_action_invoke(&mut instance); + c174_l192_action_invoke(&mut instance); + c175_l193_action_invoke(&mut instance); + c176_l194_action_invoke(&mut instance); + c177_l195_action_invoke(&mut instance); + c178_l196_action_invoke(&mut instance); + c179_l197_action_invoke(&mut instance); + c180_l198_action_invoke(&mut instance); + c181_l199_action_invoke(&mut instance); + c182_l200_action_invoke(&mut instance); + c183_l201_action_invoke(&mut instance); + c184_l202_action_invoke(&mut instance); + c185_l203_action_invoke(&mut instance); + c186_l204_action_invoke(&mut instance); + c187_l205_action_invoke(&mut instance); + c188_l206_action_invoke(&mut instance); + c189_l207_action_invoke(&mut instance); + c190_l208_action_invoke(&mut instance); + c191_l209_action_invoke(&mut instance); + c192_l210_action_invoke(&mut instance); + c193_l211_assert_return_canonical_nan(&mut instance); + c194_l212_assert_return_arithmetic_nan(&mut instance); + c195_l213_assert_return_canonical_nan(&mut instance); + c196_l214_assert_return_arithmetic_nan(&mut instance); + c197_l215_assert_return_canonical_nan(&mut instance); + c198_l216_assert_return_arithmetic_nan(&mut instance); + c199_l217_assert_return_canonical_nan(&mut instance); + c200_l218_assert_return_arithmetic_nan(&mut instance); + c201_l219_action_invoke(&mut instance); + c202_l220_action_invoke(&mut instance); + c203_l221_action_invoke(&mut instance); + c204_l222_action_invoke(&mut instance); + c205_l223_action_invoke(&mut instance); + c206_l224_action_invoke(&mut instance); + c207_l225_action_invoke(&mut instance); + c208_l226_action_invoke(&mut instance); + c209_l227_action_invoke(&mut instance); + c210_l228_action_invoke(&mut instance); + c211_l229_action_invoke(&mut instance); + c212_l230_action_invoke(&mut instance); + c213_l231_action_invoke(&mut instance); + c214_l232_action_invoke(&mut instance); + c215_l233_action_invoke(&mut instance); + c216_l234_action_invoke(&mut instance); + c217_l235_action_invoke(&mut instance); + c218_l236_action_invoke(&mut instance); + c219_l237_action_invoke(&mut instance); + c220_l238_action_invoke(&mut instance); + c221_l239_action_invoke(&mut instance); + c222_l240_action_invoke(&mut instance); + c223_l241_action_invoke(&mut instance); + c224_l242_action_invoke(&mut instance); + c225_l243_action_invoke(&mut instance); + c226_l244_action_invoke(&mut instance); + c227_l245_action_invoke(&mut instance); + c228_l246_action_invoke(&mut instance); + c229_l247_action_invoke(&mut instance); + c230_l248_action_invoke(&mut instance); + c231_l249_action_invoke(&mut instance); + c232_l250_action_invoke(&mut instance); + c233_l251_assert_return_canonical_nan(&mut instance); + c234_l252_assert_return_arithmetic_nan(&mut instance); + c235_l253_assert_return_canonical_nan(&mut instance); + c236_l254_assert_return_arithmetic_nan(&mut instance); + c237_l255_assert_return_canonical_nan(&mut instance); + c238_l256_assert_return_arithmetic_nan(&mut instance); + c239_l257_assert_return_canonical_nan(&mut instance); + c240_l258_assert_return_arithmetic_nan(&mut instance); + c241_l259_action_invoke(&mut instance); + c242_l260_action_invoke(&mut instance); + c243_l261_action_invoke(&mut instance); + c244_l262_action_invoke(&mut instance); + c245_l263_action_invoke(&mut instance); + c246_l264_action_invoke(&mut instance); + c247_l265_action_invoke(&mut instance); + c248_l266_action_invoke(&mut instance); + c249_l267_action_invoke(&mut instance); + c250_l268_action_invoke(&mut instance); + c251_l269_action_invoke(&mut instance); + c252_l270_action_invoke(&mut instance); + c253_l271_action_invoke(&mut instance); + c254_l272_action_invoke(&mut instance); + c255_l273_action_invoke(&mut instance); + c256_l274_action_invoke(&mut instance); + c257_l275_action_invoke(&mut instance); + c258_l276_action_invoke(&mut instance); + c259_l277_action_invoke(&mut instance); + c260_l278_action_invoke(&mut instance); + c261_l279_action_invoke(&mut instance); + c262_l280_action_invoke(&mut instance); + c263_l281_action_invoke(&mut instance); + c264_l282_action_invoke(&mut instance); + c265_l283_action_invoke(&mut instance); + c266_l284_action_invoke(&mut instance); + c267_l285_action_invoke(&mut instance); + c268_l286_action_invoke(&mut instance); + c269_l287_action_invoke(&mut instance); + c270_l288_action_invoke(&mut instance); + c271_l289_action_invoke(&mut instance); + c272_l290_action_invoke(&mut instance); + c273_l291_assert_return_canonical_nan(&mut instance); + c274_l292_assert_return_arithmetic_nan(&mut instance); + c275_l293_assert_return_canonical_nan(&mut instance); + c276_l294_assert_return_arithmetic_nan(&mut instance); + c277_l295_assert_return_canonical_nan(&mut instance); + c278_l296_assert_return_arithmetic_nan(&mut instance); + c279_l297_assert_return_canonical_nan(&mut instance); + c280_l298_assert_return_arithmetic_nan(&mut instance); + c281_l299_action_invoke(&mut instance); + c282_l300_action_invoke(&mut instance); + c283_l301_action_invoke(&mut instance); + c284_l302_action_invoke(&mut instance); + c285_l303_action_invoke(&mut instance); + c286_l304_action_invoke(&mut instance); + c287_l305_action_invoke(&mut instance); + c288_l306_action_invoke(&mut instance); + c289_l307_action_invoke(&mut instance); + c290_l308_action_invoke(&mut instance); + c291_l309_action_invoke(&mut instance); + c292_l310_action_invoke(&mut instance); + c293_l311_action_invoke(&mut instance); + c294_l312_action_invoke(&mut instance); + c295_l313_action_invoke(&mut instance); + c296_l314_action_invoke(&mut instance); + c297_l315_action_invoke(&mut instance); + c298_l316_action_invoke(&mut instance); + c299_l317_action_invoke(&mut instance); + c300_l318_action_invoke(&mut instance); + c301_l319_action_invoke(&mut instance); + c302_l320_action_invoke(&mut instance); + c303_l321_action_invoke(&mut instance); + c304_l322_action_invoke(&mut instance); + c305_l323_action_invoke(&mut instance); + c306_l324_action_invoke(&mut instance); + c307_l325_action_invoke(&mut instance); + c308_l326_action_invoke(&mut instance); + c309_l327_action_invoke(&mut instance); + c310_l328_assert_return_canonical_nan(&mut instance); + c311_l329_assert_return_canonical_nan(&mut instance); + c312_l330_action_invoke(&mut instance); + c313_l331_assert_return_canonical_nan(&mut instance); + c314_l332_assert_return_arithmetic_nan(&mut instance); + c315_l333_assert_return_canonical_nan(&mut instance); + c316_l334_assert_return_arithmetic_nan(&mut instance); + c317_l335_assert_return_canonical_nan(&mut instance); + c318_l336_assert_return_arithmetic_nan(&mut instance); + c319_l337_assert_return_canonical_nan(&mut instance); + c320_l338_assert_return_arithmetic_nan(&mut instance); + c321_l339_assert_return_canonical_nan(&mut instance); + c322_l340_assert_return_arithmetic_nan(&mut instance); + c323_l341_assert_return_canonical_nan(&mut instance); + c324_l342_assert_return_arithmetic_nan(&mut instance); + c325_l343_assert_return_canonical_nan(&mut instance); + c326_l344_assert_return_arithmetic_nan(&mut instance); + c327_l345_assert_return_canonical_nan(&mut instance); + c328_l346_assert_return_arithmetic_nan(&mut instance); + c329_l347_assert_return_canonical_nan(&mut instance); + c330_l348_assert_return_arithmetic_nan(&mut instance); + c331_l349_assert_return_canonical_nan(&mut instance); + c332_l350_assert_return_arithmetic_nan(&mut instance); + c333_l351_assert_return_canonical_nan(&mut instance); + c334_l352_assert_return_arithmetic_nan(&mut instance); + c335_l353_assert_return_canonical_nan(&mut instance); + c336_l354_assert_return_arithmetic_nan(&mut instance); + c337_l355_assert_return_canonical_nan(&mut instance); + c338_l356_assert_return_arithmetic_nan(&mut instance); + c339_l357_assert_return_canonical_nan(&mut instance); + c340_l358_assert_return_arithmetic_nan(&mut instance); + c341_l359_assert_return_canonical_nan(&mut instance); + c342_l360_assert_return_arithmetic_nan(&mut instance); + c343_l361_assert_return_canonical_nan(&mut instance); + c344_l362_assert_return_arithmetic_nan(&mut instance); + c345_l363_assert_return_canonical_nan(&mut instance); + c346_l364_assert_return_arithmetic_nan(&mut instance); + c347_l365_assert_return_canonical_nan(&mut instance); + c348_l366_assert_return_arithmetic_nan(&mut instance); + c349_l367_assert_return_canonical_nan(&mut instance); + c350_l368_assert_return_arithmetic_nan(&mut instance); + c351_l369_assert_return_canonical_nan(&mut instance); + c352_l370_assert_return_arithmetic_nan(&mut instance); + c353_l371_assert_return_canonical_nan(&mut instance); + c354_l372_assert_return_arithmetic_nan(&mut instance); + c355_l373_assert_return_canonical_nan(&mut instance); + c356_l374_assert_return_arithmetic_nan(&mut instance); + c357_l375_assert_return_canonical_nan(&mut instance); + c358_l376_assert_return_arithmetic_nan(&mut instance); + c359_l377_assert_return_canonical_nan(&mut instance); + c360_l378_assert_return_arithmetic_nan(&mut instance); + c361_l379_assert_return_canonical_nan(&mut instance); + c362_l380_assert_return_arithmetic_nan(&mut instance); + c363_l381_assert_return_canonical_nan(&mut instance); + c364_l382_assert_return_arithmetic_nan(&mut instance); + c365_l383_assert_return_canonical_nan(&mut instance); + c366_l384_assert_return_arithmetic_nan(&mut instance); + c367_l385_assert_return_canonical_nan(&mut instance); + c368_l386_assert_return_arithmetic_nan(&mut instance); + c369_l387_assert_return_canonical_nan(&mut instance); + c370_l388_assert_return_arithmetic_nan(&mut instance); + c371_l389_assert_return_canonical_nan(&mut instance); + c372_l390_assert_return_arithmetic_nan(&mut instance); + c373_l391_assert_return_canonical_nan(&mut instance); + c374_l392_assert_return_arithmetic_nan(&mut instance); + c375_l393_assert_return_canonical_nan(&mut instance); + c376_l394_assert_return_arithmetic_nan(&mut instance); + c377_l395_assert_return_canonical_nan(&mut instance); + c378_l396_assert_return_arithmetic_nan(&mut instance); + c379_l397_assert_return_canonical_nan(&mut instance); + c380_l398_assert_return_arithmetic_nan(&mut instance); + c381_l399_assert_return_canonical_nan(&mut instance); + c382_l400_assert_return_arithmetic_nan(&mut instance); + c383_l401_assert_return_canonical_nan(&mut instance); + c384_l402_assert_return_arithmetic_nan(&mut instance); + c385_l403_assert_return_canonical_nan(&mut instance); + c386_l404_assert_return_arithmetic_nan(&mut instance); + c387_l405_assert_return_arithmetic_nan(&mut instance); + c388_l406_assert_return_arithmetic_nan(&mut instance); + c389_l407_assert_return_canonical_nan(&mut instance); + c390_l408_assert_return_arithmetic_nan(&mut instance); + c391_l409_assert_return_arithmetic_nan(&mut instance); + c392_l410_assert_return_arithmetic_nan(&mut instance); + c393_l411_assert_return_canonical_nan(&mut instance); + c394_l412_assert_return_arithmetic_nan(&mut instance); + c395_l413_assert_return_arithmetic_nan(&mut instance); + c396_l414_assert_return_arithmetic_nan(&mut instance); + c397_l415_assert_return_canonical_nan(&mut instance); + c398_l416_assert_return_arithmetic_nan(&mut instance); + c399_l417_assert_return_arithmetic_nan(&mut instance); + c400_l418_assert_return_arithmetic_nan(&mut instance); + c401_l419_action_invoke(&mut instance); + c402_l420_action_invoke(&mut instance); + c403_l421_action_invoke(&mut instance); + c404_l422_action_invoke(&mut instance); + c405_l423_action_invoke(&mut instance); + c406_l424_action_invoke(&mut instance); + c407_l425_action_invoke(&mut instance); + c408_l426_action_invoke(&mut instance); + c409_l427_action_invoke(&mut instance); + c410_l428_action_invoke(&mut instance); + c411_l429_action_invoke(&mut instance); + c412_l430_action_invoke(&mut instance); + c413_l431_action_invoke(&mut instance); + c414_l432_action_invoke(&mut instance); + c415_l433_action_invoke(&mut instance); + c416_l434_action_invoke(&mut instance); + c417_l435_action_invoke(&mut instance); + c418_l436_action_invoke(&mut instance); + c419_l437_action_invoke(&mut instance); + c420_l438_action_invoke(&mut instance); + c421_l439_action_invoke(&mut instance); + c422_l440_action_invoke(&mut instance); + c423_l441_action_invoke(&mut instance); + c424_l442_action_invoke(&mut instance); + c425_l443_action_invoke(&mut instance); + c426_l444_action_invoke(&mut instance); + c427_l445_action_invoke(&mut instance); + c428_l446_action_invoke(&mut instance); + c429_l447_action_invoke(&mut instance); + c430_l448_action_invoke(&mut instance); + c431_l449_action_invoke(&mut instance); + c432_l450_action_invoke(&mut instance); + c433_l451_assert_return_canonical_nan(&mut instance); + c434_l452_assert_return_arithmetic_nan(&mut instance); + c435_l453_assert_return_canonical_nan(&mut instance); + c436_l454_assert_return_arithmetic_nan(&mut instance); + c437_l455_assert_return_canonical_nan(&mut instance); + c438_l456_assert_return_arithmetic_nan(&mut instance); + c439_l457_assert_return_canonical_nan(&mut instance); + c440_l458_assert_return_arithmetic_nan(&mut instance); + c441_l459_action_invoke(&mut instance); + c442_l460_action_invoke(&mut instance); + c443_l461_action_invoke(&mut instance); + c444_l462_action_invoke(&mut instance); + c445_l463_action_invoke(&mut instance); + c446_l464_action_invoke(&mut instance); + c447_l465_action_invoke(&mut instance); + c448_l466_action_invoke(&mut instance); + c449_l467_action_invoke(&mut instance); + c450_l468_action_invoke(&mut instance); + c451_l469_action_invoke(&mut instance); + c452_l470_action_invoke(&mut instance); + c453_l471_action_invoke(&mut instance); + c454_l472_action_invoke(&mut instance); + c455_l473_action_invoke(&mut instance); + c456_l474_action_invoke(&mut instance); + c457_l475_action_invoke(&mut instance); + c458_l476_action_invoke(&mut instance); + c459_l477_action_invoke(&mut instance); + c460_l478_action_invoke(&mut instance); + c461_l479_action_invoke(&mut instance); + c462_l480_action_invoke(&mut instance); + c463_l481_action_invoke(&mut instance); + c464_l482_action_invoke(&mut instance); + c465_l483_action_invoke(&mut instance); + c466_l484_action_invoke(&mut instance); + c467_l485_action_invoke(&mut instance); + c468_l486_action_invoke(&mut instance); + c469_l487_action_invoke(&mut instance); + c470_l488_action_invoke(&mut instance); + c471_l489_action_invoke(&mut instance); + c472_l490_action_invoke(&mut instance); + c473_l491_assert_return_canonical_nan(&mut instance); + c474_l492_assert_return_arithmetic_nan(&mut instance); + c475_l493_assert_return_canonical_nan(&mut instance); + c476_l494_assert_return_arithmetic_nan(&mut instance); + c477_l495_assert_return_canonical_nan(&mut instance); + c478_l496_assert_return_arithmetic_nan(&mut instance); + c479_l497_assert_return_canonical_nan(&mut instance); + c480_l498_assert_return_arithmetic_nan(&mut instance); + c481_l499_action_invoke(&mut instance); + c482_l500_action_invoke(&mut instance); + c483_l501_action_invoke(&mut instance); + c484_l502_action_invoke(&mut instance); + c485_l503_action_invoke(&mut instance); + c486_l504_action_invoke(&mut instance); + c487_l505_action_invoke(&mut instance); + c488_l506_action_invoke(&mut instance); + c489_l507_action_invoke(&mut instance); + c490_l508_action_invoke(&mut instance); + c491_l509_action_invoke(&mut instance); + c492_l510_action_invoke(&mut instance); + c493_l511_action_invoke(&mut instance); + c494_l512_action_invoke(&mut instance); + c495_l513_action_invoke(&mut instance); + c496_l514_action_invoke(&mut instance); + c497_l515_action_invoke(&mut instance); + c498_l516_action_invoke(&mut instance); + c499_l517_action_invoke(&mut instance); + c500_l518_action_invoke(&mut instance); + c501_l519_action_invoke(&mut instance); + c502_l520_action_invoke(&mut instance); + c503_l521_action_invoke(&mut instance); + c504_l522_action_invoke(&mut instance); + c505_l523_action_invoke(&mut instance); + c506_l524_action_invoke(&mut instance); + c507_l525_action_invoke(&mut instance); + c508_l526_action_invoke(&mut instance); + c509_l527_action_invoke(&mut instance); + c510_l528_action_invoke(&mut instance); + c511_l529_action_invoke(&mut instance); + c512_l530_action_invoke(&mut instance); + c513_l531_assert_return_canonical_nan(&mut instance); + c514_l532_assert_return_arithmetic_nan(&mut instance); + c515_l533_assert_return_canonical_nan(&mut instance); + c516_l534_assert_return_arithmetic_nan(&mut instance); + c517_l535_assert_return_canonical_nan(&mut instance); + c518_l536_assert_return_arithmetic_nan(&mut instance); + c519_l537_assert_return_canonical_nan(&mut instance); + c520_l538_assert_return_arithmetic_nan(&mut instance); + c521_l539_action_invoke(&mut instance); + c522_l540_action_invoke(&mut instance); + c523_l541_action_invoke(&mut instance); + c524_l542_action_invoke(&mut instance); + c525_l543_action_invoke(&mut instance); + c526_l544_action_invoke(&mut instance); + c527_l545_action_invoke(&mut instance); + c528_l546_action_invoke(&mut instance); + c529_l547_action_invoke(&mut instance); + c530_l548_action_invoke(&mut instance); + c531_l549_action_invoke(&mut instance); + c532_l550_action_invoke(&mut instance); + c533_l551_action_invoke(&mut instance); + c534_l552_action_invoke(&mut instance); + c535_l553_action_invoke(&mut instance); + c536_l554_action_invoke(&mut instance); + c537_l555_action_invoke(&mut instance); + c538_l556_action_invoke(&mut instance); + c539_l557_action_invoke(&mut instance); + c540_l558_action_invoke(&mut instance); + c541_l559_action_invoke(&mut instance); + c542_l560_action_invoke(&mut instance); + c543_l561_action_invoke(&mut instance); + c544_l562_action_invoke(&mut instance); + c545_l563_action_invoke(&mut instance); + c546_l564_action_invoke(&mut instance); + c547_l565_action_invoke(&mut instance); + c548_l566_action_invoke(&mut instance); + c549_l567_action_invoke(&mut instance); + c550_l568_action_invoke(&mut instance); + c551_l569_action_invoke(&mut instance); + c552_l570_action_invoke(&mut instance); + c553_l571_assert_return_canonical_nan(&mut instance); + c554_l572_assert_return_arithmetic_nan(&mut instance); + c555_l573_assert_return_canonical_nan(&mut instance); + c556_l574_assert_return_arithmetic_nan(&mut instance); + c557_l575_assert_return_canonical_nan(&mut instance); + c558_l576_assert_return_arithmetic_nan(&mut instance); + c559_l577_assert_return_canonical_nan(&mut instance); + c560_l578_assert_return_arithmetic_nan(&mut instance); + c561_l579_action_invoke(&mut instance); + c562_l580_action_invoke(&mut instance); + c563_l581_action_invoke(&mut instance); + c564_l582_action_invoke(&mut instance); + c565_l583_action_invoke(&mut instance); + c566_l584_action_invoke(&mut instance); + c567_l585_action_invoke(&mut instance); + c568_l586_action_invoke(&mut instance); + c569_l587_action_invoke(&mut instance); + c570_l588_action_invoke(&mut instance); + c571_l589_action_invoke(&mut instance); + c572_l590_action_invoke(&mut instance); + c573_l591_action_invoke(&mut instance); + c574_l592_action_invoke(&mut instance); + c575_l593_action_invoke(&mut instance); + c576_l594_action_invoke(&mut instance); + c577_l595_action_invoke(&mut instance); + c578_l596_action_invoke(&mut instance); + c579_l597_action_invoke(&mut instance); + c580_l598_action_invoke(&mut instance); + c581_l599_action_invoke(&mut instance); + c582_l600_action_invoke(&mut instance); + c583_l601_action_invoke(&mut instance); + c584_l602_action_invoke(&mut instance); + c585_l603_action_invoke(&mut instance); + c586_l604_action_invoke(&mut instance); + c587_l605_action_invoke(&mut instance); + c588_l606_action_invoke(&mut instance); + c589_l607_action_invoke(&mut instance); + c590_l608_action_invoke(&mut instance); + c591_l609_action_invoke(&mut instance); + c592_l610_action_invoke(&mut instance); + c593_l611_assert_return_canonical_nan(&mut instance); + c594_l612_assert_return_arithmetic_nan(&mut instance); + c595_l613_assert_return_canonical_nan(&mut instance); + c596_l614_assert_return_arithmetic_nan(&mut instance); + c597_l615_assert_return_canonical_nan(&mut instance); + c598_l616_assert_return_arithmetic_nan(&mut instance); + c599_l617_assert_return_canonical_nan(&mut instance); + c600_l618_assert_return_arithmetic_nan(&mut instance); + c601_l619_action_invoke(&mut instance); + c602_l620_action_invoke(&mut instance); + c603_l621_action_invoke(&mut instance); + c604_l622_action_invoke(&mut instance); + c605_l623_action_invoke(&mut instance); + c606_l624_action_invoke(&mut instance); + c607_l625_action_invoke(&mut instance); + c608_l626_action_invoke(&mut instance); + c609_l627_action_invoke(&mut instance); + c610_l628_action_invoke(&mut instance); + c611_l629_action_invoke(&mut instance); + c612_l630_action_invoke(&mut instance); + c613_l631_action_invoke(&mut instance); + c614_l632_action_invoke(&mut instance); + c615_l633_action_invoke(&mut instance); + c616_l634_action_invoke(&mut instance); + c617_l635_action_invoke(&mut instance); + c618_l636_action_invoke(&mut instance); + c619_l637_action_invoke(&mut instance); + c620_l638_action_invoke(&mut instance); + c621_l639_action_invoke(&mut instance); + c622_l640_action_invoke(&mut instance); + c623_l641_action_invoke(&mut instance); + c624_l642_action_invoke(&mut instance); + c625_l643_action_invoke(&mut instance); + c626_l644_action_invoke(&mut instance); + c627_l645_action_invoke(&mut instance); + c628_l646_action_invoke(&mut instance); + c629_l647_action_invoke(&mut instance); + c630_l648_action_invoke(&mut instance); + c631_l649_action_invoke(&mut instance); + c632_l650_action_invoke(&mut instance); + c633_l651_assert_return_canonical_nan(&mut instance); + c634_l652_assert_return_arithmetic_nan(&mut instance); + c635_l653_assert_return_canonical_nan(&mut instance); + c636_l654_assert_return_arithmetic_nan(&mut instance); + c637_l655_assert_return_canonical_nan(&mut instance); + c638_l656_assert_return_arithmetic_nan(&mut instance); + c639_l657_assert_return_canonical_nan(&mut instance); + c640_l658_assert_return_arithmetic_nan(&mut instance); + c641_l659_action_invoke(&mut instance); + c642_l660_action_invoke(&mut instance); + c643_l661_action_invoke(&mut instance); + c644_l662_action_invoke(&mut instance); + c645_l663_action_invoke(&mut instance); + c646_l664_action_invoke(&mut instance); + c647_l665_action_invoke(&mut instance); + c648_l666_action_invoke(&mut instance); + c649_l667_action_invoke(&mut instance); + c650_l668_action_invoke(&mut instance); + c651_l669_action_invoke(&mut instance); + c652_l670_action_invoke(&mut instance); + c653_l671_action_invoke(&mut instance); + c654_l672_action_invoke(&mut instance); + c655_l673_action_invoke(&mut instance); + c656_l674_action_invoke(&mut instance); + c657_l675_action_invoke(&mut instance); + c658_l676_action_invoke(&mut instance); + c659_l677_action_invoke(&mut instance); + c660_l678_action_invoke(&mut instance); + c661_l679_action_invoke(&mut instance); + c662_l680_action_invoke(&mut instance); + c663_l681_action_invoke(&mut instance); + c664_l682_action_invoke(&mut instance); + c665_l683_action_invoke(&mut instance); + c666_l684_action_invoke(&mut instance); + c667_l685_action_invoke(&mut instance); + c668_l686_action_invoke(&mut instance); + c669_l687_action_invoke(&mut instance); + c670_l688_action_invoke(&mut instance); + c671_l689_action_invoke(&mut instance); + c672_l690_action_invoke(&mut instance); + c673_l691_assert_return_canonical_nan(&mut instance); + c674_l692_assert_return_arithmetic_nan(&mut instance); + c675_l693_assert_return_canonical_nan(&mut instance); + c676_l694_assert_return_arithmetic_nan(&mut instance); + c677_l695_assert_return_canonical_nan(&mut instance); + c678_l696_assert_return_arithmetic_nan(&mut instance); + c679_l697_assert_return_canonical_nan(&mut instance); + c680_l698_assert_return_arithmetic_nan(&mut instance); + c681_l699_action_invoke(&mut instance); + c682_l700_action_invoke(&mut instance); + c683_l701_action_invoke(&mut instance); + c684_l702_action_invoke(&mut instance); + c685_l703_action_invoke(&mut instance); + c686_l704_action_invoke(&mut instance); + c687_l705_action_invoke(&mut instance); + c688_l706_action_invoke(&mut instance); + c689_l707_action_invoke(&mut instance); + c690_l708_action_invoke(&mut instance); + c691_l709_action_invoke(&mut instance); + c692_l710_action_invoke(&mut instance); + c693_l711_action_invoke(&mut instance); + c694_l712_action_invoke(&mut instance); + c695_l713_action_invoke(&mut instance); + c696_l714_action_invoke(&mut instance); + c697_l715_action_invoke(&mut instance); + c698_l716_action_invoke(&mut instance); + c699_l717_action_invoke(&mut instance); + c700_l718_action_invoke(&mut instance); + c701_l719_action_invoke(&mut instance); + c702_l720_action_invoke(&mut instance); + c703_l721_action_invoke(&mut instance); + c704_l722_action_invoke(&mut instance); + c705_l723_action_invoke(&mut instance); + c706_l724_action_invoke(&mut instance); + c707_l725_action_invoke(&mut instance); + c708_l726_action_invoke(&mut instance); + c709_l727_assert_return_canonical_nan(&mut instance); + c710_l728_action_invoke(&mut instance); + c711_l729_action_invoke(&mut instance); + c712_l730_assert_return_canonical_nan(&mut instance); + c713_l731_assert_return_canonical_nan(&mut instance); + c714_l732_assert_return_arithmetic_nan(&mut instance); + c715_l733_assert_return_canonical_nan(&mut instance); + c716_l734_assert_return_arithmetic_nan(&mut instance); + c717_l735_assert_return_canonical_nan(&mut instance); + c718_l736_assert_return_arithmetic_nan(&mut instance); + c719_l737_assert_return_canonical_nan(&mut instance); + c720_l738_assert_return_arithmetic_nan(&mut instance); + c721_l739_assert_return_canonical_nan(&mut instance); + c722_l740_assert_return_arithmetic_nan(&mut instance); + c723_l741_assert_return_canonical_nan(&mut instance); + c724_l742_assert_return_arithmetic_nan(&mut instance); + c725_l743_assert_return_canonical_nan(&mut instance); + c726_l744_assert_return_arithmetic_nan(&mut instance); + c727_l745_assert_return_canonical_nan(&mut instance); + c728_l746_assert_return_arithmetic_nan(&mut instance); + c729_l747_assert_return_canonical_nan(&mut instance); + c730_l748_assert_return_arithmetic_nan(&mut instance); + c731_l749_assert_return_canonical_nan(&mut instance); + c732_l750_assert_return_arithmetic_nan(&mut instance); + c733_l751_assert_return_canonical_nan(&mut instance); + c734_l752_assert_return_arithmetic_nan(&mut instance); + c735_l753_assert_return_canonical_nan(&mut instance); + c736_l754_assert_return_arithmetic_nan(&mut instance); + c737_l755_assert_return_canonical_nan(&mut instance); + c738_l756_assert_return_arithmetic_nan(&mut instance); + c739_l757_assert_return_canonical_nan(&mut instance); + c740_l758_assert_return_arithmetic_nan(&mut instance); + c741_l759_assert_return_canonical_nan(&mut instance); + c742_l760_assert_return_arithmetic_nan(&mut instance); + c743_l761_assert_return_canonical_nan(&mut instance); + c744_l762_assert_return_arithmetic_nan(&mut instance); + c745_l763_assert_return_canonical_nan(&mut instance); + c746_l764_assert_return_arithmetic_nan(&mut instance); + c747_l765_assert_return_canonical_nan(&mut instance); + c748_l766_assert_return_arithmetic_nan(&mut instance); + c749_l767_assert_return_canonical_nan(&mut instance); + c750_l768_assert_return_arithmetic_nan(&mut instance); + c751_l769_assert_return_canonical_nan(&mut instance); + c752_l770_assert_return_arithmetic_nan(&mut instance); + c753_l771_assert_return_canonical_nan(&mut instance); + c754_l772_assert_return_arithmetic_nan(&mut instance); + c755_l773_assert_return_canonical_nan(&mut instance); + c756_l774_assert_return_arithmetic_nan(&mut instance); + c757_l775_assert_return_canonical_nan(&mut instance); + c758_l776_assert_return_arithmetic_nan(&mut instance); + c759_l777_assert_return_canonical_nan(&mut instance); + c760_l778_assert_return_arithmetic_nan(&mut instance); + c761_l779_assert_return_canonical_nan(&mut instance); + c762_l780_assert_return_arithmetic_nan(&mut instance); + c763_l781_assert_return_canonical_nan(&mut instance); + c764_l782_assert_return_arithmetic_nan(&mut instance); + c765_l783_assert_return_canonical_nan(&mut instance); + c766_l784_assert_return_arithmetic_nan(&mut instance); + c767_l785_assert_return_canonical_nan(&mut instance); + c768_l786_assert_return_arithmetic_nan(&mut instance); + c769_l787_assert_return_canonical_nan(&mut instance); + c770_l788_assert_return_arithmetic_nan(&mut instance); + c771_l789_assert_return_canonical_nan(&mut instance); + c772_l790_assert_return_arithmetic_nan(&mut instance); + c773_l791_assert_return_canonical_nan(&mut instance); + c774_l792_assert_return_arithmetic_nan(&mut instance); + c775_l793_assert_return_canonical_nan(&mut instance); + c776_l794_assert_return_arithmetic_nan(&mut instance); + c777_l795_assert_return_canonical_nan(&mut instance); + c778_l796_assert_return_arithmetic_nan(&mut instance); + c779_l797_assert_return_canonical_nan(&mut instance); + c780_l798_assert_return_arithmetic_nan(&mut instance); + c781_l799_assert_return_canonical_nan(&mut instance); + c782_l800_assert_return_arithmetic_nan(&mut instance); + c783_l801_assert_return_canonical_nan(&mut instance); + c784_l802_assert_return_arithmetic_nan(&mut instance); + c785_l803_assert_return_canonical_nan(&mut instance); + c786_l804_assert_return_arithmetic_nan(&mut instance); + c787_l805_assert_return_arithmetic_nan(&mut instance); + c788_l806_assert_return_arithmetic_nan(&mut instance); + c789_l807_assert_return_canonical_nan(&mut instance); + c790_l808_assert_return_arithmetic_nan(&mut instance); + c791_l809_assert_return_arithmetic_nan(&mut instance); + c792_l810_assert_return_arithmetic_nan(&mut instance); + c793_l811_assert_return_canonical_nan(&mut instance); + c794_l812_assert_return_arithmetic_nan(&mut instance); + c795_l813_assert_return_arithmetic_nan(&mut instance); + c796_l814_assert_return_arithmetic_nan(&mut instance); + c797_l815_assert_return_canonical_nan(&mut instance); + c798_l816_assert_return_arithmetic_nan(&mut instance); + c799_l817_assert_return_arithmetic_nan(&mut instance); + c800_l818_assert_return_arithmetic_nan(&mut instance); + c801_l819_action_invoke(&mut instance); + c802_l820_action_invoke(&mut instance); + c803_l821_action_invoke(&mut instance); + c804_l822_action_invoke(&mut instance); + c805_l823_action_invoke(&mut instance); + c806_l824_action_invoke(&mut instance); + c807_l825_action_invoke(&mut instance); + c808_l826_action_invoke(&mut instance); + c809_l827_action_invoke(&mut instance); + c810_l828_action_invoke(&mut instance); + c811_l829_action_invoke(&mut instance); + c812_l830_action_invoke(&mut instance); + c813_l831_action_invoke(&mut instance); + c814_l832_action_invoke(&mut instance); + c815_l833_action_invoke(&mut instance); + c816_l834_action_invoke(&mut instance); + c817_l835_action_invoke(&mut instance); + c818_l836_action_invoke(&mut instance); + c819_l837_action_invoke(&mut instance); + c820_l838_action_invoke(&mut instance); + c821_l839_action_invoke(&mut instance); + c822_l840_action_invoke(&mut instance); + c823_l841_action_invoke(&mut instance); + c824_l842_action_invoke(&mut instance); + c825_l843_action_invoke(&mut instance); + c826_l844_action_invoke(&mut instance); + c827_l845_action_invoke(&mut instance); + c828_l846_action_invoke(&mut instance); + c829_l847_assert_return_canonical_nan(&mut instance); + c830_l848_assert_return_canonical_nan(&mut instance); + c831_l849_assert_return_canonical_nan(&mut instance); + c832_l850_assert_return_canonical_nan(&mut instance); + c833_l851_assert_return_canonical_nan(&mut instance); + c834_l852_assert_return_arithmetic_nan(&mut instance); + c835_l853_assert_return_canonical_nan(&mut instance); + c836_l854_assert_return_arithmetic_nan(&mut instance); + c837_l855_assert_return_canonical_nan(&mut instance); + c838_l856_assert_return_arithmetic_nan(&mut instance); + c839_l857_assert_return_canonical_nan(&mut instance); + c840_l858_assert_return_arithmetic_nan(&mut instance); + c841_l859_action_invoke(&mut instance); + c842_l860_action_invoke(&mut instance); + c843_l861_action_invoke(&mut instance); + c844_l862_action_invoke(&mut instance); + c845_l863_action_invoke(&mut instance); + c846_l864_action_invoke(&mut instance); + c847_l865_action_invoke(&mut instance); + c848_l866_action_invoke(&mut instance); + c849_l867_action_invoke(&mut instance); + c850_l868_action_invoke(&mut instance); + c851_l869_action_invoke(&mut instance); + c852_l870_action_invoke(&mut instance); + c853_l871_action_invoke(&mut instance); + c854_l872_action_invoke(&mut instance); + c855_l873_action_invoke(&mut instance); + c856_l874_action_invoke(&mut instance); + c857_l875_action_invoke(&mut instance); + c858_l876_action_invoke(&mut instance); + c859_l877_action_invoke(&mut instance); + c860_l878_action_invoke(&mut instance); + c861_l879_action_invoke(&mut instance); + c862_l880_action_invoke(&mut instance); + c863_l881_action_invoke(&mut instance); + c864_l882_action_invoke(&mut instance); + c865_l883_action_invoke(&mut instance); + c866_l884_action_invoke(&mut instance); + c867_l885_action_invoke(&mut instance); + c868_l886_action_invoke(&mut instance); + c869_l887_action_invoke(&mut instance); + c870_l888_action_invoke(&mut instance); + c871_l889_action_invoke(&mut instance); + c872_l890_action_invoke(&mut instance); + c873_l891_assert_return_canonical_nan(&mut instance); + c874_l892_assert_return_arithmetic_nan(&mut instance); + c875_l893_assert_return_canonical_nan(&mut instance); + c876_l894_assert_return_arithmetic_nan(&mut instance); + c877_l895_assert_return_canonical_nan(&mut instance); + c878_l896_assert_return_arithmetic_nan(&mut instance); + c879_l897_assert_return_canonical_nan(&mut instance); + c880_l898_assert_return_arithmetic_nan(&mut instance); + c881_l899_action_invoke(&mut instance); + c882_l900_action_invoke(&mut instance); + c883_l901_action_invoke(&mut instance); + c884_l902_action_invoke(&mut instance); + c885_l903_action_invoke(&mut instance); + c886_l904_action_invoke(&mut instance); + c887_l905_action_invoke(&mut instance); + c888_l906_action_invoke(&mut instance); + c889_l907_action_invoke(&mut instance); + c890_l908_action_invoke(&mut instance); + c891_l909_action_invoke(&mut instance); + c892_l910_action_invoke(&mut instance); + c893_l911_action_invoke(&mut instance); + c894_l912_action_invoke(&mut instance); + c895_l913_action_invoke(&mut instance); + c896_l914_action_invoke(&mut instance); + c897_l915_action_invoke(&mut instance); + c898_l916_action_invoke(&mut instance); + c899_l917_action_invoke(&mut instance); + c900_l918_action_invoke(&mut instance); + c901_l919_action_invoke(&mut instance); + c902_l920_action_invoke(&mut instance); + c903_l921_action_invoke(&mut instance); + c904_l922_action_invoke(&mut instance); + c905_l923_action_invoke(&mut instance); + c906_l924_action_invoke(&mut instance); + c907_l925_action_invoke(&mut instance); + c908_l926_action_invoke(&mut instance); + c909_l927_action_invoke(&mut instance); + c910_l928_action_invoke(&mut instance); + c911_l929_action_invoke(&mut instance); + c912_l930_action_invoke(&mut instance); + c913_l931_assert_return_canonical_nan(&mut instance); + c914_l932_assert_return_arithmetic_nan(&mut instance); + c915_l933_assert_return_canonical_nan(&mut instance); + c916_l934_assert_return_arithmetic_nan(&mut instance); + c917_l935_assert_return_canonical_nan(&mut instance); + c918_l936_assert_return_arithmetic_nan(&mut instance); + c919_l937_assert_return_canonical_nan(&mut instance); + c920_l938_assert_return_arithmetic_nan(&mut instance); + c921_l939_action_invoke(&mut instance); + c922_l940_action_invoke(&mut instance); + c923_l941_action_invoke(&mut instance); + c924_l942_action_invoke(&mut instance); + c925_l943_action_invoke(&mut instance); + c926_l944_action_invoke(&mut instance); + c927_l945_action_invoke(&mut instance); + c928_l946_action_invoke(&mut instance); + c929_l947_action_invoke(&mut instance); + c930_l948_action_invoke(&mut instance); + c931_l949_action_invoke(&mut instance); + c932_l950_action_invoke(&mut instance); + c933_l951_action_invoke(&mut instance); + c934_l952_action_invoke(&mut instance); + c935_l953_action_invoke(&mut instance); + c936_l954_action_invoke(&mut instance); + c937_l955_action_invoke(&mut instance); + c938_l956_action_invoke(&mut instance); + c939_l957_action_invoke(&mut instance); + c940_l958_action_invoke(&mut instance); + c941_l959_action_invoke(&mut instance); + c942_l960_action_invoke(&mut instance); + c943_l961_action_invoke(&mut instance); + c944_l962_action_invoke(&mut instance); + c945_l963_action_invoke(&mut instance); + c946_l964_action_invoke(&mut instance); + c947_l965_action_invoke(&mut instance); + c948_l966_action_invoke(&mut instance); + c949_l967_action_invoke(&mut instance); + c950_l968_action_invoke(&mut instance); + c951_l969_action_invoke(&mut instance); + c952_l970_action_invoke(&mut instance); + c953_l971_assert_return_canonical_nan(&mut instance); + c954_l972_assert_return_arithmetic_nan(&mut instance); + c955_l973_assert_return_canonical_nan(&mut instance); + c956_l974_assert_return_arithmetic_nan(&mut instance); + c957_l975_assert_return_canonical_nan(&mut instance); + c958_l976_assert_return_arithmetic_nan(&mut instance); + c959_l977_assert_return_canonical_nan(&mut instance); + c960_l978_assert_return_arithmetic_nan(&mut instance); + c961_l979_action_invoke(&mut instance); + c962_l980_action_invoke(&mut instance); + c963_l981_action_invoke(&mut instance); + c964_l982_action_invoke(&mut instance); + c965_l983_action_invoke(&mut instance); + c966_l984_action_invoke(&mut instance); + c967_l985_action_invoke(&mut instance); + c968_l986_action_invoke(&mut instance); + c969_l987_action_invoke(&mut instance); + c970_l988_action_invoke(&mut instance); + c971_l989_action_invoke(&mut instance); + c972_l990_action_invoke(&mut instance); + c973_l991_action_invoke(&mut instance); + c974_l992_action_invoke(&mut instance); + c975_l993_action_invoke(&mut instance); + c976_l994_action_invoke(&mut instance); + c977_l995_action_invoke(&mut instance); + c978_l996_action_invoke(&mut instance); + c979_l997_action_invoke(&mut instance); + c980_l998_action_invoke(&mut instance); + c981_l999_action_invoke(&mut instance); + c982_l1000_action_invoke(&mut instance); + c983_l1001_action_invoke(&mut instance); + c984_l1002_action_invoke(&mut instance); + c985_l1003_action_invoke(&mut instance); + c986_l1004_action_invoke(&mut instance); + c987_l1005_action_invoke(&mut instance); + c988_l1006_action_invoke(&mut instance); + c989_l1007_action_invoke(&mut instance); + c990_l1008_action_invoke(&mut instance); + c991_l1009_action_invoke(&mut instance); + c992_l1010_action_invoke(&mut instance); + c993_l1011_assert_return_canonical_nan(&mut instance); + c994_l1012_assert_return_arithmetic_nan(&mut instance); + c995_l1013_assert_return_canonical_nan(&mut instance); + c996_l1014_assert_return_arithmetic_nan(&mut instance); + c997_l1015_assert_return_canonical_nan(&mut instance); + c998_l1016_assert_return_arithmetic_nan(&mut instance); + c999_l1017_assert_return_canonical_nan(&mut instance); + c1000_l1018_assert_return_arithmetic_nan(&mut instance); + c1001_l1019_action_invoke(&mut instance); + c1002_l1020_action_invoke(&mut instance); + c1003_l1021_action_invoke(&mut instance); + c1004_l1022_action_invoke(&mut instance); + c1005_l1023_action_invoke(&mut instance); + c1006_l1024_action_invoke(&mut instance); + c1007_l1025_action_invoke(&mut instance); + c1008_l1026_action_invoke(&mut instance); + c1009_l1027_action_invoke(&mut instance); + c1010_l1028_action_invoke(&mut instance); + c1011_l1029_action_invoke(&mut instance); + c1012_l1030_action_invoke(&mut instance); + c1013_l1031_action_invoke(&mut instance); + c1014_l1032_action_invoke(&mut instance); + c1015_l1033_action_invoke(&mut instance); + c1016_l1034_action_invoke(&mut instance); + c1017_l1035_action_invoke(&mut instance); + c1018_l1036_action_invoke(&mut instance); + c1019_l1037_action_invoke(&mut instance); + c1020_l1038_action_invoke(&mut instance); + c1021_l1039_action_invoke(&mut instance); + c1022_l1040_action_invoke(&mut instance); + c1023_l1041_action_invoke(&mut instance); + c1024_l1042_action_invoke(&mut instance); + c1025_l1043_action_invoke(&mut instance); + c1026_l1044_action_invoke(&mut instance); + c1027_l1045_action_invoke(&mut instance); + c1028_l1046_action_invoke(&mut instance); + c1029_l1047_action_invoke(&mut instance); + c1030_l1048_action_invoke(&mut instance); + c1031_l1049_action_invoke(&mut instance); + c1032_l1050_action_invoke(&mut instance); + c1033_l1051_assert_return_canonical_nan(&mut instance); + c1034_l1052_assert_return_arithmetic_nan(&mut instance); + c1035_l1053_assert_return_canonical_nan(&mut instance); + c1036_l1054_assert_return_arithmetic_nan(&mut instance); + c1037_l1055_assert_return_canonical_nan(&mut instance); + c1038_l1056_assert_return_arithmetic_nan(&mut instance); + c1039_l1057_assert_return_canonical_nan(&mut instance); + c1040_l1058_assert_return_arithmetic_nan(&mut instance); + c1041_l1059_action_invoke(&mut instance); + c1042_l1060_action_invoke(&mut instance); + c1043_l1061_action_invoke(&mut instance); + c1044_l1062_action_invoke(&mut instance); + c1045_l1063_action_invoke(&mut instance); + c1046_l1064_action_invoke(&mut instance); + c1047_l1065_action_invoke(&mut instance); + c1048_l1066_action_invoke(&mut instance); + c1049_l1067_action_invoke(&mut instance); + c1050_l1068_action_invoke(&mut instance); + c1051_l1069_action_invoke(&mut instance); + c1052_l1070_action_invoke(&mut instance); + c1053_l1071_action_invoke(&mut instance); + c1054_l1072_action_invoke(&mut instance); + c1055_l1073_action_invoke(&mut instance); + c1056_l1074_action_invoke(&mut instance); + c1057_l1075_action_invoke(&mut instance); + c1058_l1076_action_invoke(&mut instance); + c1059_l1077_action_invoke(&mut instance); + c1060_l1078_action_invoke(&mut instance); + c1061_l1079_action_invoke(&mut instance); + c1062_l1080_action_invoke(&mut instance); + c1063_l1081_action_invoke(&mut instance); + c1064_l1082_action_invoke(&mut instance); + c1065_l1083_action_invoke(&mut instance); + c1066_l1084_action_invoke(&mut instance); + c1067_l1085_action_invoke(&mut instance); + c1068_l1086_action_invoke(&mut instance); + c1069_l1087_action_invoke(&mut instance); + c1070_l1088_action_invoke(&mut instance); + c1071_l1089_action_invoke(&mut instance); + c1072_l1090_action_invoke(&mut instance); + c1073_l1091_assert_return_canonical_nan(&mut instance); + c1074_l1092_assert_return_arithmetic_nan(&mut instance); + c1075_l1093_assert_return_canonical_nan(&mut instance); + c1076_l1094_assert_return_arithmetic_nan(&mut instance); + c1077_l1095_assert_return_canonical_nan(&mut instance); + c1078_l1096_assert_return_arithmetic_nan(&mut instance); + c1079_l1097_assert_return_canonical_nan(&mut instance); + c1080_l1098_assert_return_arithmetic_nan(&mut instance); + c1081_l1099_assert_return_canonical_nan(&mut instance); + c1082_l1100_assert_return_canonical_nan(&mut instance); + c1083_l1101_assert_return_canonical_nan(&mut instance); + c1084_l1102_assert_return_canonical_nan(&mut instance); + c1085_l1103_action_invoke(&mut instance); + c1086_l1104_action_invoke(&mut instance); + c1087_l1105_action_invoke(&mut instance); + c1088_l1106_action_invoke(&mut instance); + c1089_l1107_action_invoke(&mut instance); + c1090_l1108_action_invoke(&mut instance); + c1091_l1109_action_invoke(&mut instance); + c1092_l1110_action_invoke(&mut instance); + c1093_l1111_action_invoke(&mut instance); + c1094_l1112_action_invoke(&mut instance); + c1095_l1113_action_invoke(&mut instance); + c1096_l1114_action_invoke(&mut instance); + c1097_l1115_action_invoke(&mut instance); + c1098_l1116_action_invoke(&mut instance); + c1099_l1117_action_invoke(&mut instance); + c1100_l1118_action_invoke(&mut instance); + c1101_l1119_action_invoke(&mut instance); + c1102_l1120_action_invoke(&mut instance); + c1103_l1121_action_invoke(&mut instance); + c1104_l1122_action_invoke(&mut instance); + c1105_l1123_action_invoke(&mut instance); + c1106_l1124_action_invoke(&mut instance); + c1107_l1125_action_invoke(&mut instance); + c1108_l1126_action_invoke(&mut instance); + c1109_l1127_action_invoke(&mut instance); + c1110_l1128_action_invoke(&mut instance); + c1111_l1129_action_invoke(&mut instance); + c1112_l1130_action_invoke(&mut instance); + c1113_l1131_assert_return_canonical_nan(&mut instance); + c1114_l1132_assert_return_arithmetic_nan(&mut instance); + c1115_l1133_assert_return_canonical_nan(&mut instance); + c1116_l1134_assert_return_arithmetic_nan(&mut instance); + c1117_l1135_assert_return_canonical_nan(&mut instance); + c1118_l1136_assert_return_arithmetic_nan(&mut instance); + c1119_l1137_assert_return_canonical_nan(&mut instance); + c1120_l1138_assert_return_arithmetic_nan(&mut instance); + c1121_l1139_assert_return_canonical_nan(&mut instance); + c1122_l1140_assert_return_arithmetic_nan(&mut instance); + c1123_l1141_assert_return_canonical_nan(&mut instance); + c1124_l1142_assert_return_arithmetic_nan(&mut instance); + c1125_l1143_assert_return_canonical_nan(&mut instance); + c1126_l1144_assert_return_arithmetic_nan(&mut instance); + c1127_l1145_assert_return_canonical_nan(&mut instance); + c1128_l1146_assert_return_arithmetic_nan(&mut instance); + c1129_l1147_assert_return_canonical_nan(&mut instance); + c1130_l1148_assert_return_arithmetic_nan(&mut instance); + c1131_l1149_assert_return_canonical_nan(&mut instance); + c1132_l1150_assert_return_arithmetic_nan(&mut instance); + c1133_l1151_assert_return_canonical_nan(&mut instance); + c1134_l1152_assert_return_arithmetic_nan(&mut instance); + c1135_l1153_assert_return_canonical_nan(&mut instance); + c1136_l1154_assert_return_arithmetic_nan(&mut instance); + c1137_l1155_assert_return_canonical_nan(&mut instance); + c1138_l1156_assert_return_arithmetic_nan(&mut instance); + c1139_l1157_assert_return_canonical_nan(&mut instance); + c1140_l1158_assert_return_arithmetic_nan(&mut instance); + c1141_l1159_assert_return_canonical_nan(&mut instance); + c1142_l1160_assert_return_arithmetic_nan(&mut instance); + c1143_l1161_assert_return_canonical_nan(&mut instance); + c1144_l1162_assert_return_arithmetic_nan(&mut instance); + c1145_l1163_assert_return_canonical_nan(&mut instance); + c1146_l1164_assert_return_arithmetic_nan(&mut instance); + c1147_l1165_assert_return_canonical_nan(&mut instance); + c1148_l1166_assert_return_arithmetic_nan(&mut instance); + c1149_l1167_assert_return_canonical_nan(&mut instance); + c1150_l1168_assert_return_arithmetic_nan(&mut instance); + c1151_l1169_assert_return_canonical_nan(&mut instance); + c1152_l1170_assert_return_arithmetic_nan(&mut instance); + c1153_l1171_assert_return_canonical_nan(&mut instance); + c1154_l1172_assert_return_arithmetic_nan(&mut instance); + c1155_l1173_assert_return_canonical_nan(&mut instance); + c1156_l1174_assert_return_arithmetic_nan(&mut instance); + c1157_l1175_assert_return_canonical_nan(&mut instance); + c1158_l1176_assert_return_arithmetic_nan(&mut instance); + c1159_l1177_assert_return_canonical_nan(&mut instance); + c1160_l1178_assert_return_arithmetic_nan(&mut instance); + c1161_l1179_assert_return_canonical_nan(&mut instance); + c1162_l1180_assert_return_arithmetic_nan(&mut instance); + c1163_l1181_assert_return_canonical_nan(&mut instance); + c1164_l1182_assert_return_arithmetic_nan(&mut instance); + c1165_l1183_assert_return_canonical_nan(&mut instance); + c1166_l1184_assert_return_arithmetic_nan(&mut instance); + c1167_l1185_assert_return_canonical_nan(&mut instance); + c1168_l1186_assert_return_arithmetic_nan(&mut instance); + c1169_l1187_assert_return_canonical_nan(&mut instance); + c1170_l1188_assert_return_arithmetic_nan(&mut instance); + c1171_l1189_assert_return_canonical_nan(&mut instance); + c1172_l1190_assert_return_arithmetic_nan(&mut instance); + c1173_l1191_assert_return_canonical_nan(&mut instance); + c1174_l1192_assert_return_arithmetic_nan(&mut instance); + c1175_l1193_assert_return_canonical_nan(&mut instance); + c1176_l1194_assert_return_arithmetic_nan(&mut instance); + c1177_l1195_assert_return_canonical_nan(&mut instance); + c1178_l1196_assert_return_arithmetic_nan(&mut instance); + c1179_l1197_assert_return_canonical_nan(&mut instance); + c1180_l1198_assert_return_arithmetic_nan(&mut instance); + c1181_l1199_assert_return_canonical_nan(&mut instance); + c1182_l1200_assert_return_arithmetic_nan(&mut instance); + c1183_l1201_assert_return_canonical_nan(&mut instance); + c1184_l1202_assert_return_arithmetic_nan(&mut instance); + c1185_l1203_assert_return_canonical_nan(&mut instance); + c1186_l1204_assert_return_arithmetic_nan(&mut instance); + c1187_l1205_assert_return_arithmetic_nan(&mut instance); + c1188_l1206_assert_return_arithmetic_nan(&mut instance); + c1189_l1207_assert_return_canonical_nan(&mut instance); + c1190_l1208_assert_return_arithmetic_nan(&mut instance); + c1191_l1209_assert_return_arithmetic_nan(&mut instance); + c1192_l1210_assert_return_arithmetic_nan(&mut instance); + c1193_l1211_assert_return_canonical_nan(&mut instance); + c1194_l1212_assert_return_arithmetic_nan(&mut instance); + c1195_l1213_assert_return_arithmetic_nan(&mut instance); + c1196_l1214_assert_return_arithmetic_nan(&mut instance); + c1197_l1215_assert_return_canonical_nan(&mut instance); + c1198_l1216_assert_return_arithmetic_nan(&mut instance); + c1199_l1217_assert_return_arithmetic_nan(&mut instance); + c1200_l1218_assert_return_arithmetic_nan(&mut instance); + c1201_l1219_assert_return_canonical_nan(&mut instance); + c1202_l1220_assert_return_canonical_nan(&mut instance); + c1203_l1221_assert_return_canonical_nan(&mut instance); + c1204_l1222_assert_return_canonical_nan(&mut instance); + c1205_l1223_action_invoke(&mut instance); + c1206_l1224_action_invoke(&mut instance); + c1207_l1225_action_invoke(&mut instance); + c1208_l1226_action_invoke(&mut instance); + c1209_l1227_action_invoke(&mut instance); + c1210_l1228_action_invoke(&mut instance); + c1211_l1229_action_invoke(&mut instance); + c1212_l1230_action_invoke(&mut instance); + c1213_l1231_action_invoke(&mut instance); + c1214_l1232_action_invoke(&mut instance); + c1215_l1233_action_invoke(&mut instance); + c1216_l1234_action_invoke(&mut instance); + c1217_l1235_action_invoke(&mut instance); + c1218_l1236_action_invoke(&mut instance); + c1219_l1237_action_invoke(&mut instance); + c1220_l1238_action_invoke(&mut instance); + c1221_l1239_action_invoke(&mut instance); + c1222_l1240_action_invoke(&mut instance); + c1223_l1241_action_invoke(&mut instance); + c1224_l1242_action_invoke(&mut instance); + c1225_l1243_action_invoke(&mut instance); + c1226_l1244_action_invoke(&mut instance); + c1227_l1245_action_invoke(&mut instance); + c1228_l1246_action_invoke(&mut instance); + c1229_l1247_action_invoke(&mut instance); + c1230_l1248_action_invoke(&mut instance); + c1231_l1249_action_invoke(&mut instance); + c1232_l1250_action_invoke(&mut instance); + c1233_l1251_assert_return_canonical_nan(&mut instance); + c1234_l1252_assert_return_arithmetic_nan(&mut instance); + c1235_l1253_assert_return_canonical_nan(&mut instance); + c1236_l1254_assert_return_arithmetic_nan(&mut instance); + c1237_l1255_assert_return_canonical_nan(&mut instance); + c1238_l1256_assert_return_arithmetic_nan(&mut instance); + c1239_l1257_assert_return_canonical_nan(&mut instance); + c1240_l1258_assert_return_arithmetic_nan(&mut instance); + c1241_l1259_action_invoke(&mut instance); + c1242_l1260_action_invoke(&mut instance); + c1243_l1261_action_invoke(&mut instance); + c1244_l1262_action_invoke(&mut instance); + c1245_l1263_action_invoke(&mut instance); + c1246_l1264_action_invoke(&mut instance); + c1247_l1265_action_invoke(&mut instance); + c1248_l1266_action_invoke(&mut instance); + c1249_l1267_action_invoke(&mut instance); + c1250_l1268_action_invoke(&mut instance); + c1251_l1269_action_invoke(&mut instance); + c1252_l1270_action_invoke(&mut instance); + c1253_l1271_action_invoke(&mut instance); + c1254_l1272_action_invoke(&mut instance); + c1255_l1273_action_invoke(&mut instance); + c1256_l1274_action_invoke(&mut instance); + c1257_l1275_action_invoke(&mut instance); + c1258_l1276_action_invoke(&mut instance); + c1259_l1277_action_invoke(&mut instance); + c1260_l1278_action_invoke(&mut instance); + c1261_l1279_action_invoke(&mut instance); + c1262_l1280_action_invoke(&mut instance); + c1263_l1281_action_invoke(&mut instance); + c1264_l1282_action_invoke(&mut instance); + c1265_l1283_action_invoke(&mut instance); + c1266_l1284_action_invoke(&mut instance); + c1267_l1285_action_invoke(&mut instance); + c1268_l1286_action_invoke(&mut instance); + c1269_l1287_action_invoke(&mut instance); + c1270_l1288_action_invoke(&mut instance); + c1271_l1289_action_invoke(&mut instance); + c1272_l1290_action_invoke(&mut instance); + c1273_l1291_assert_return_canonical_nan(&mut instance); + c1274_l1292_assert_return_arithmetic_nan(&mut instance); + c1275_l1293_assert_return_canonical_nan(&mut instance); + c1276_l1294_assert_return_arithmetic_nan(&mut instance); + c1277_l1295_assert_return_canonical_nan(&mut instance); + c1278_l1296_assert_return_arithmetic_nan(&mut instance); + c1279_l1297_assert_return_canonical_nan(&mut instance); + c1280_l1298_assert_return_arithmetic_nan(&mut instance); + c1281_l1299_action_invoke(&mut instance); + c1282_l1300_action_invoke(&mut instance); + c1283_l1301_action_invoke(&mut instance); + c1284_l1302_action_invoke(&mut instance); + c1285_l1303_action_invoke(&mut instance); + c1286_l1304_action_invoke(&mut instance); + c1287_l1305_action_invoke(&mut instance); + c1288_l1306_action_invoke(&mut instance); + c1289_l1307_action_invoke(&mut instance); + c1290_l1308_action_invoke(&mut instance); + c1291_l1309_action_invoke(&mut instance); + c1292_l1310_action_invoke(&mut instance); + c1293_l1311_action_invoke(&mut instance); + c1294_l1312_action_invoke(&mut instance); + c1295_l1313_action_invoke(&mut instance); + c1296_l1314_action_invoke(&mut instance); + c1297_l1315_action_invoke(&mut instance); + c1298_l1316_action_invoke(&mut instance); + c1299_l1317_action_invoke(&mut instance); + c1300_l1318_action_invoke(&mut instance); + c1301_l1319_action_invoke(&mut instance); + c1302_l1320_action_invoke(&mut instance); + c1303_l1321_action_invoke(&mut instance); + c1304_l1322_action_invoke(&mut instance); + c1305_l1323_action_invoke(&mut instance); + c1306_l1324_action_invoke(&mut instance); + c1307_l1325_action_invoke(&mut instance); + c1308_l1326_action_invoke(&mut instance); + c1309_l1327_action_invoke(&mut instance); + c1310_l1328_action_invoke(&mut instance); + c1311_l1329_action_invoke(&mut instance); + c1312_l1330_action_invoke(&mut instance); + c1313_l1331_assert_return_canonical_nan(&mut instance); + c1314_l1332_assert_return_arithmetic_nan(&mut instance); + c1315_l1333_assert_return_canonical_nan(&mut instance); + c1316_l1334_assert_return_arithmetic_nan(&mut instance); + c1317_l1335_assert_return_canonical_nan(&mut instance); + c1318_l1336_assert_return_arithmetic_nan(&mut instance); + c1319_l1337_assert_return_canonical_nan(&mut instance); + c1320_l1338_assert_return_arithmetic_nan(&mut instance); + c1321_l1339_action_invoke(&mut instance); + c1322_l1340_action_invoke(&mut instance); + c1323_l1341_action_invoke(&mut instance); + c1324_l1342_action_invoke(&mut instance); + c1325_l1343_action_invoke(&mut instance); + c1326_l1344_action_invoke(&mut instance); + c1327_l1345_action_invoke(&mut instance); + c1328_l1346_action_invoke(&mut instance); + c1329_l1347_action_invoke(&mut instance); + c1330_l1348_action_invoke(&mut instance); + c1331_l1349_action_invoke(&mut instance); + c1332_l1350_action_invoke(&mut instance); + c1333_l1351_action_invoke(&mut instance); + c1334_l1352_action_invoke(&mut instance); + c1335_l1353_action_invoke(&mut instance); + c1336_l1354_action_invoke(&mut instance); + c1337_l1355_action_invoke(&mut instance); + c1338_l1356_action_invoke(&mut instance); + c1339_l1357_action_invoke(&mut instance); + c1340_l1358_action_invoke(&mut instance); + c1341_l1359_action_invoke(&mut instance); + c1342_l1360_action_invoke(&mut instance); + c1343_l1361_action_invoke(&mut instance); + c1344_l1362_action_invoke(&mut instance); + c1345_l1363_action_invoke(&mut instance); + c1346_l1364_action_invoke(&mut instance); + c1347_l1365_action_invoke(&mut instance); + c1348_l1366_action_invoke(&mut instance); + c1349_l1367_action_invoke(&mut instance); + c1350_l1368_action_invoke(&mut instance); + c1351_l1369_action_invoke(&mut instance); + c1352_l1370_action_invoke(&mut instance); + c1353_l1371_assert_return_canonical_nan(&mut instance); + c1354_l1372_assert_return_arithmetic_nan(&mut instance); + c1355_l1373_assert_return_canonical_nan(&mut instance); + c1356_l1374_assert_return_arithmetic_nan(&mut instance); + c1357_l1375_assert_return_canonical_nan(&mut instance); + c1358_l1376_assert_return_arithmetic_nan(&mut instance); + c1359_l1377_assert_return_canonical_nan(&mut instance); + c1360_l1378_assert_return_arithmetic_nan(&mut instance); + c1361_l1379_action_invoke(&mut instance); + c1362_l1380_action_invoke(&mut instance); + c1363_l1381_action_invoke(&mut instance); + c1364_l1382_action_invoke(&mut instance); + c1365_l1383_action_invoke(&mut instance); + c1366_l1384_action_invoke(&mut instance); + c1367_l1385_action_invoke(&mut instance); + c1368_l1386_action_invoke(&mut instance); + c1369_l1387_action_invoke(&mut instance); + c1370_l1388_action_invoke(&mut instance); + c1371_l1389_action_invoke(&mut instance); + c1372_l1390_action_invoke(&mut instance); + c1373_l1391_action_invoke(&mut instance); + c1374_l1392_action_invoke(&mut instance); + c1375_l1393_action_invoke(&mut instance); + c1376_l1394_action_invoke(&mut instance); + c1377_l1395_action_invoke(&mut instance); + c1378_l1396_action_invoke(&mut instance); + c1379_l1397_action_invoke(&mut instance); + c1380_l1398_action_invoke(&mut instance); + c1381_l1399_action_invoke(&mut instance); + c1382_l1400_action_invoke(&mut instance); + c1383_l1401_action_invoke(&mut instance); + c1384_l1402_action_invoke(&mut instance); + c1385_l1403_action_invoke(&mut instance); + c1386_l1404_action_invoke(&mut instance); + c1387_l1405_action_invoke(&mut instance); + c1388_l1406_action_invoke(&mut instance); + c1389_l1407_action_invoke(&mut instance); + c1390_l1408_action_invoke(&mut instance); + c1391_l1409_action_invoke(&mut instance); + c1392_l1410_action_invoke(&mut instance); + c1393_l1411_assert_return_canonical_nan(&mut instance); + c1394_l1412_assert_return_arithmetic_nan(&mut instance); + c1395_l1413_assert_return_canonical_nan(&mut instance); + c1396_l1414_assert_return_arithmetic_nan(&mut instance); + c1397_l1415_assert_return_canonical_nan(&mut instance); + c1398_l1416_assert_return_arithmetic_nan(&mut instance); + c1399_l1417_assert_return_canonical_nan(&mut instance); + c1400_l1418_assert_return_arithmetic_nan(&mut instance); + c1401_l1419_action_invoke(&mut instance); + c1402_l1420_action_invoke(&mut instance); + c1403_l1421_action_invoke(&mut instance); + c1404_l1422_action_invoke(&mut instance); + c1405_l1423_action_invoke(&mut instance); + c1406_l1424_action_invoke(&mut instance); + c1407_l1425_action_invoke(&mut instance); + c1408_l1426_action_invoke(&mut instance); + c1409_l1427_action_invoke(&mut instance); + c1410_l1428_action_invoke(&mut instance); + c1411_l1429_action_invoke(&mut instance); + c1412_l1430_action_invoke(&mut instance); + c1413_l1431_action_invoke(&mut instance); + c1414_l1432_action_invoke(&mut instance); + c1415_l1433_action_invoke(&mut instance); + c1416_l1434_action_invoke(&mut instance); + c1417_l1435_action_invoke(&mut instance); + c1418_l1436_action_invoke(&mut instance); + c1419_l1437_action_invoke(&mut instance); + c1420_l1438_action_invoke(&mut instance); + c1421_l1439_action_invoke(&mut instance); + c1422_l1440_action_invoke(&mut instance); + c1423_l1441_action_invoke(&mut instance); + c1424_l1442_action_invoke(&mut instance); + c1425_l1443_action_invoke(&mut instance); + c1426_l1444_action_invoke(&mut instance); + c1427_l1445_action_invoke(&mut instance); + c1428_l1446_action_invoke(&mut instance); + c1429_l1447_action_invoke(&mut instance); + c1430_l1448_action_invoke(&mut instance); + c1431_l1449_action_invoke(&mut instance); + c1432_l1450_action_invoke(&mut instance); + c1433_l1451_assert_return_canonical_nan(&mut instance); + c1434_l1452_assert_return_arithmetic_nan(&mut instance); + c1435_l1453_assert_return_canonical_nan(&mut instance); + c1436_l1454_assert_return_arithmetic_nan(&mut instance); + c1437_l1455_assert_return_canonical_nan(&mut instance); + c1438_l1456_assert_return_arithmetic_nan(&mut instance); + c1439_l1457_assert_return_canonical_nan(&mut instance); + c1440_l1458_assert_return_arithmetic_nan(&mut instance); + c1441_l1459_action_invoke(&mut instance); + c1442_l1460_action_invoke(&mut instance); + c1443_l1461_action_invoke(&mut instance); + c1444_l1462_action_invoke(&mut instance); + c1445_l1463_action_invoke(&mut instance); + c1446_l1464_action_invoke(&mut instance); + c1447_l1465_action_invoke(&mut instance); + c1448_l1466_action_invoke(&mut instance); + c1449_l1467_action_invoke(&mut instance); + c1450_l1468_action_invoke(&mut instance); + c1451_l1469_action_invoke(&mut instance); + c1452_l1470_action_invoke(&mut instance); + c1453_l1471_action_invoke(&mut instance); + c1454_l1472_action_invoke(&mut instance); + c1455_l1473_action_invoke(&mut instance); + c1456_l1474_action_invoke(&mut instance); + c1457_l1475_action_invoke(&mut instance); + c1458_l1476_action_invoke(&mut instance); + c1459_l1477_action_invoke(&mut instance); + c1460_l1478_action_invoke(&mut instance); + c1461_l1479_action_invoke(&mut instance); + c1462_l1480_action_invoke(&mut instance); + c1463_l1481_action_invoke(&mut instance); + c1464_l1482_action_invoke(&mut instance); + c1465_l1483_action_invoke(&mut instance); + c1466_l1484_action_invoke(&mut instance); + c1467_l1485_action_invoke(&mut instance); + c1468_l1486_action_invoke(&mut instance); + c1469_l1487_action_invoke(&mut instance); + c1470_l1488_action_invoke(&mut instance); + c1471_l1489_action_invoke(&mut instance); + c1472_l1490_action_invoke(&mut instance); + c1473_l1491_assert_return_canonical_nan(&mut instance); + c1474_l1492_assert_return_arithmetic_nan(&mut instance); + c1475_l1493_assert_return_canonical_nan(&mut instance); + c1476_l1494_assert_return_arithmetic_nan(&mut instance); + c1477_l1495_assert_return_canonical_nan(&mut instance); + c1478_l1496_assert_return_arithmetic_nan(&mut instance); + c1479_l1497_assert_return_canonical_nan(&mut instance); + c1480_l1498_assert_return_arithmetic_nan(&mut instance); + c1481_l1499_action_invoke(&mut instance); + c1482_l1500_action_invoke(&mut instance); + c1483_l1501_action_invoke(&mut instance); + c1484_l1502_action_invoke(&mut instance); + c1485_l1503_action_invoke(&mut instance); + c1486_l1504_action_invoke(&mut instance); + c1487_l1505_action_invoke(&mut instance); + c1488_l1506_action_invoke(&mut instance); + c1489_l1507_action_invoke(&mut instance); + c1490_l1508_action_invoke(&mut instance); + c1491_l1509_action_invoke(&mut instance); + c1492_l1510_action_invoke(&mut instance); + c1493_l1511_action_invoke(&mut instance); + c1494_l1512_action_invoke(&mut instance); + c1495_l1513_action_invoke(&mut instance); + c1496_l1514_action_invoke(&mut instance); + c1497_l1515_action_invoke(&mut instance); + c1498_l1516_action_invoke(&mut instance); + c1499_l1517_action_invoke(&mut instance); + c1500_l1518_action_invoke(&mut instance); + c1501_l1519_action_invoke(&mut instance); + c1502_l1520_action_invoke(&mut instance); + c1503_l1521_action_invoke(&mut instance); + c1504_l1522_action_invoke(&mut instance); + c1505_l1523_action_invoke(&mut instance); + c1506_l1524_action_invoke(&mut instance); + c1507_l1525_action_invoke(&mut instance); + c1508_l1526_action_invoke(&mut instance); + c1509_l1527_assert_return_canonical_nan(&mut instance); + c1510_l1528_assert_return_canonical_nan(&mut instance); + c1511_l1529_assert_return_canonical_nan(&mut instance); + c1512_l1530_assert_return_canonical_nan(&mut instance); + c1513_l1531_assert_return_canonical_nan(&mut instance); + c1514_l1532_assert_return_arithmetic_nan(&mut instance); + c1515_l1533_assert_return_canonical_nan(&mut instance); + c1516_l1534_assert_return_arithmetic_nan(&mut instance); + c1517_l1535_assert_return_canonical_nan(&mut instance); + c1518_l1536_assert_return_arithmetic_nan(&mut instance); + c1519_l1537_assert_return_canonical_nan(&mut instance); + c1520_l1538_assert_return_arithmetic_nan(&mut instance); + c1521_l1539_assert_return_canonical_nan(&mut instance); + c1522_l1540_assert_return_arithmetic_nan(&mut instance); + c1523_l1541_assert_return_canonical_nan(&mut instance); + c1524_l1542_assert_return_arithmetic_nan(&mut instance); + c1525_l1543_assert_return_canonical_nan(&mut instance); + c1526_l1544_assert_return_arithmetic_nan(&mut instance); + c1527_l1545_assert_return_canonical_nan(&mut instance); + c1528_l1546_assert_return_arithmetic_nan(&mut instance); + c1529_l1547_assert_return_canonical_nan(&mut instance); + c1530_l1548_assert_return_arithmetic_nan(&mut instance); + c1531_l1549_assert_return_canonical_nan(&mut instance); + c1532_l1550_assert_return_arithmetic_nan(&mut instance); + c1533_l1551_assert_return_canonical_nan(&mut instance); + c1534_l1552_assert_return_arithmetic_nan(&mut instance); + c1535_l1553_assert_return_canonical_nan(&mut instance); + c1536_l1554_assert_return_arithmetic_nan(&mut instance); + c1537_l1555_assert_return_canonical_nan(&mut instance); + c1538_l1556_assert_return_arithmetic_nan(&mut instance); + c1539_l1557_assert_return_canonical_nan(&mut instance); + c1540_l1558_assert_return_arithmetic_nan(&mut instance); + c1541_l1559_assert_return_canonical_nan(&mut instance); + c1542_l1560_assert_return_arithmetic_nan(&mut instance); + c1543_l1561_assert_return_canonical_nan(&mut instance); + c1544_l1562_assert_return_arithmetic_nan(&mut instance); + c1545_l1563_assert_return_canonical_nan(&mut instance); + c1546_l1564_assert_return_arithmetic_nan(&mut instance); + c1547_l1565_assert_return_canonical_nan(&mut instance); + c1548_l1566_assert_return_arithmetic_nan(&mut instance); + c1549_l1567_assert_return_canonical_nan(&mut instance); + c1550_l1568_assert_return_arithmetic_nan(&mut instance); + c1551_l1569_assert_return_canonical_nan(&mut instance); + c1552_l1570_assert_return_arithmetic_nan(&mut instance); + c1553_l1571_assert_return_canonical_nan(&mut instance); + c1554_l1572_assert_return_arithmetic_nan(&mut instance); + c1555_l1573_assert_return_canonical_nan(&mut instance); + c1556_l1574_assert_return_arithmetic_nan(&mut instance); + c1557_l1575_assert_return_canonical_nan(&mut instance); + c1558_l1576_assert_return_arithmetic_nan(&mut instance); + c1559_l1577_assert_return_canonical_nan(&mut instance); + c1560_l1578_assert_return_arithmetic_nan(&mut instance); + c1561_l1579_assert_return_canonical_nan(&mut instance); + c1562_l1580_assert_return_arithmetic_nan(&mut instance); + c1563_l1581_assert_return_canonical_nan(&mut instance); + c1564_l1582_assert_return_arithmetic_nan(&mut instance); + c1565_l1583_assert_return_canonical_nan(&mut instance); + c1566_l1584_assert_return_arithmetic_nan(&mut instance); + c1567_l1585_assert_return_canonical_nan(&mut instance); + c1568_l1586_assert_return_arithmetic_nan(&mut instance); + c1569_l1587_assert_return_canonical_nan(&mut instance); + c1570_l1588_assert_return_arithmetic_nan(&mut instance); + c1571_l1589_assert_return_canonical_nan(&mut instance); + c1572_l1590_assert_return_arithmetic_nan(&mut instance); + c1573_l1591_assert_return_canonical_nan(&mut instance); + c1574_l1592_assert_return_arithmetic_nan(&mut instance); + c1575_l1593_assert_return_canonical_nan(&mut instance); + c1576_l1594_assert_return_arithmetic_nan(&mut instance); + c1577_l1595_assert_return_canonical_nan(&mut instance); + c1578_l1596_assert_return_arithmetic_nan(&mut instance); + c1579_l1597_assert_return_canonical_nan(&mut instance); + c1580_l1598_assert_return_arithmetic_nan(&mut instance); + c1581_l1599_assert_return_canonical_nan(&mut instance); + c1582_l1600_assert_return_arithmetic_nan(&mut instance); + c1583_l1601_assert_return_canonical_nan(&mut instance); + c1584_l1602_assert_return_arithmetic_nan(&mut instance); + c1585_l1603_assert_return_canonical_nan(&mut instance); + c1586_l1604_assert_return_arithmetic_nan(&mut instance); + c1587_l1605_assert_return_arithmetic_nan(&mut instance); + c1588_l1606_assert_return_arithmetic_nan(&mut instance); + c1589_l1607_assert_return_canonical_nan(&mut instance); + c1590_l1608_assert_return_arithmetic_nan(&mut instance); + c1591_l1609_assert_return_arithmetic_nan(&mut instance); + c1592_l1610_assert_return_arithmetic_nan(&mut instance); + c1593_l1611_assert_return_canonical_nan(&mut instance); + c1594_l1612_assert_return_arithmetic_nan(&mut instance); + c1595_l1613_assert_return_arithmetic_nan(&mut instance); + c1596_l1614_assert_return_arithmetic_nan(&mut instance); + c1597_l1615_assert_return_canonical_nan(&mut instance); + c1598_l1616_assert_return_arithmetic_nan(&mut instance); + c1599_l1617_assert_return_arithmetic_nan(&mut instance); + c1600_l1618_assert_return_arithmetic_nan(&mut instance); + c1601_l1619_action_invoke(&mut instance); + c1602_l1620_action_invoke(&mut instance); + c1603_l1621_action_invoke(&mut instance); + c1604_l1622_action_invoke(&mut instance); + c1605_l1623_action_invoke(&mut instance); + c1606_l1624_action_invoke(&mut instance); + c1607_l1625_action_invoke(&mut instance); + c1608_l1626_action_invoke(&mut instance); + c1609_l1627_action_invoke(&mut instance); + c1610_l1628_action_invoke(&mut instance); + c1611_l1629_action_invoke(&mut instance); + c1612_l1630_action_invoke(&mut instance); + c1613_l1631_action_invoke(&mut instance); + c1614_l1632_action_invoke(&mut instance); + c1615_l1633_action_invoke(&mut instance); + c1616_l1634_action_invoke(&mut instance); + c1617_l1635_action_invoke(&mut instance); + c1618_l1636_action_invoke(&mut instance); + c1619_l1637_action_invoke(&mut instance); + c1620_l1638_action_invoke(&mut instance); + c1621_l1639_action_invoke(&mut instance); + c1622_l1640_action_invoke(&mut instance); + c1623_l1641_action_invoke(&mut instance); + c1624_l1642_action_invoke(&mut instance); + c1625_l1643_action_invoke(&mut instance); + c1626_l1644_action_invoke(&mut instance); + c1627_l1645_action_invoke(&mut instance); + c1628_l1646_action_invoke(&mut instance); + c1629_l1647_action_invoke(&mut instance); + c1630_l1648_action_invoke(&mut instance); + c1631_l1649_action_invoke(&mut instance); + c1632_l1650_action_invoke(&mut instance); + c1633_l1651_assert_return_canonical_nan(&mut instance); + c1634_l1652_assert_return_arithmetic_nan(&mut instance); + c1635_l1653_assert_return_canonical_nan(&mut instance); + c1636_l1654_assert_return_arithmetic_nan(&mut instance); + c1637_l1655_assert_return_canonical_nan(&mut instance); + c1638_l1656_assert_return_arithmetic_nan(&mut instance); + c1639_l1657_assert_return_canonical_nan(&mut instance); + c1640_l1658_assert_return_arithmetic_nan(&mut instance); + c1641_l1659_action_invoke(&mut instance); + c1642_l1660_action_invoke(&mut instance); + c1643_l1661_action_invoke(&mut instance); + c1644_l1662_action_invoke(&mut instance); + c1645_l1663_action_invoke(&mut instance); + c1646_l1664_action_invoke(&mut instance); + c1647_l1665_action_invoke(&mut instance); + c1648_l1666_action_invoke(&mut instance); + c1649_l1667_action_invoke(&mut instance); + c1650_l1668_action_invoke(&mut instance); + c1651_l1669_action_invoke(&mut instance); + c1652_l1670_action_invoke(&mut instance); + c1653_l1671_action_invoke(&mut instance); + c1654_l1672_action_invoke(&mut instance); + c1655_l1673_action_invoke(&mut instance); + c1656_l1674_action_invoke(&mut instance); + c1657_l1675_action_invoke(&mut instance); + c1658_l1676_action_invoke(&mut instance); + c1659_l1677_action_invoke(&mut instance); + c1660_l1678_action_invoke(&mut instance); + c1661_l1679_action_invoke(&mut instance); + c1662_l1680_action_invoke(&mut instance); + c1663_l1681_action_invoke(&mut instance); + c1664_l1682_action_invoke(&mut instance); + c1665_l1683_action_invoke(&mut instance); + c1666_l1684_action_invoke(&mut instance); + c1667_l1685_action_invoke(&mut instance); + c1668_l1686_action_invoke(&mut instance); + c1669_l1687_action_invoke(&mut instance); + c1670_l1688_action_invoke(&mut instance); + c1671_l1689_action_invoke(&mut instance); + c1672_l1690_action_invoke(&mut instance); + c1673_l1691_assert_return_canonical_nan(&mut instance); + c1674_l1692_assert_return_arithmetic_nan(&mut instance); + c1675_l1693_assert_return_canonical_nan(&mut instance); + c1676_l1694_assert_return_arithmetic_nan(&mut instance); + c1677_l1695_assert_return_canonical_nan(&mut instance); + c1678_l1696_assert_return_arithmetic_nan(&mut instance); + c1679_l1697_assert_return_canonical_nan(&mut instance); + c1680_l1698_assert_return_arithmetic_nan(&mut instance); + c1681_l1699_action_invoke(&mut instance); + c1682_l1700_action_invoke(&mut instance); + c1683_l1701_action_invoke(&mut instance); + c1684_l1702_action_invoke(&mut instance); + c1685_l1703_action_invoke(&mut instance); + c1686_l1704_action_invoke(&mut instance); + c1687_l1705_action_invoke(&mut instance); + c1688_l1706_action_invoke(&mut instance); + c1689_l1707_action_invoke(&mut instance); + c1690_l1708_action_invoke(&mut instance); + c1691_l1709_action_invoke(&mut instance); + c1692_l1710_action_invoke(&mut instance); + c1693_l1711_action_invoke(&mut instance); + c1694_l1712_action_invoke(&mut instance); + c1695_l1713_action_invoke(&mut instance); + c1696_l1714_action_invoke(&mut instance); + c1697_l1715_action_invoke(&mut instance); + c1698_l1716_action_invoke(&mut instance); + c1699_l1717_action_invoke(&mut instance); + c1700_l1718_action_invoke(&mut instance); + c1701_l1719_action_invoke(&mut instance); + c1702_l1720_action_invoke(&mut instance); + c1703_l1721_action_invoke(&mut instance); + c1704_l1722_action_invoke(&mut instance); + c1705_l1723_action_invoke(&mut instance); + c1706_l1724_action_invoke(&mut instance); + c1707_l1725_action_invoke(&mut instance); + c1708_l1726_action_invoke(&mut instance); + c1709_l1727_action_invoke(&mut instance); + c1710_l1728_action_invoke(&mut instance); + c1711_l1729_action_invoke(&mut instance); + c1712_l1730_action_invoke(&mut instance); + c1713_l1731_assert_return_canonical_nan(&mut instance); + c1714_l1732_assert_return_arithmetic_nan(&mut instance); + c1715_l1733_assert_return_canonical_nan(&mut instance); + c1716_l1734_assert_return_arithmetic_nan(&mut instance); + c1717_l1735_assert_return_canonical_nan(&mut instance); + c1718_l1736_assert_return_arithmetic_nan(&mut instance); + c1719_l1737_assert_return_canonical_nan(&mut instance); + c1720_l1738_assert_return_arithmetic_nan(&mut instance); + c1721_l1739_action_invoke(&mut instance); + c1722_l1740_action_invoke(&mut instance); + c1723_l1741_action_invoke(&mut instance); + c1724_l1742_action_invoke(&mut instance); + c1725_l1743_action_invoke(&mut instance); + c1726_l1744_action_invoke(&mut instance); + c1727_l1745_action_invoke(&mut instance); + c1728_l1746_action_invoke(&mut instance); + c1729_l1747_action_invoke(&mut instance); + c1730_l1748_action_invoke(&mut instance); + c1731_l1749_action_invoke(&mut instance); + c1732_l1750_action_invoke(&mut instance); + c1733_l1751_action_invoke(&mut instance); + c1734_l1752_action_invoke(&mut instance); + c1735_l1753_action_invoke(&mut instance); + c1736_l1754_action_invoke(&mut instance); + c1737_l1755_action_invoke(&mut instance); + c1738_l1756_action_invoke(&mut instance); + c1739_l1757_action_invoke(&mut instance); + c1740_l1758_action_invoke(&mut instance); + c1741_l1759_action_invoke(&mut instance); + c1742_l1760_action_invoke(&mut instance); + c1743_l1761_action_invoke(&mut instance); + c1744_l1762_action_invoke(&mut instance); + c1745_l1763_action_invoke(&mut instance); + c1746_l1764_action_invoke(&mut instance); + c1747_l1765_action_invoke(&mut instance); + c1748_l1766_action_invoke(&mut instance); + c1749_l1767_action_invoke(&mut instance); + c1750_l1768_action_invoke(&mut instance); + c1751_l1769_action_invoke(&mut instance); + c1752_l1770_action_invoke(&mut instance); + c1753_l1771_assert_return_canonical_nan(&mut instance); + c1754_l1772_assert_return_arithmetic_nan(&mut instance); + c1755_l1773_assert_return_canonical_nan(&mut instance); + c1756_l1774_assert_return_arithmetic_nan(&mut instance); + c1757_l1775_assert_return_canonical_nan(&mut instance); + c1758_l1776_assert_return_arithmetic_nan(&mut instance); + c1759_l1777_assert_return_canonical_nan(&mut instance); + c1760_l1778_assert_return_arithmetic_nan(&mut instance); + c1761_l1779_action_invoke(&mut instance); + c1762_l1780_action_invoke(&mut instance); + c1763_l1781_action_invoke(&mut instance); + c1764_l1782_action_invoke(&mut instance); + c1765_l1783_action_invoke(&mut instance); + c1766_l1784_action_invoke(&mut instance); + c1767_l1785_action_invoke(&mut instance); + c1768_l1786_action_invoke(&mut instance); + c1769_l1787_action_invoke(&mut instance); + c1770_l1788_action_invoke(&mut instance); + c1771_l1789_action_invoke(&mut instance); + c1772_l1790_action_invoke(&mut instance); + c1773_l1791_action_invoke(&mut instance); + c1774_l1792_action_invoke(&mut instance); + c1775_l1793_action_invoke(&mut instance); + c1776_l1794_action_invoke(&mut instance); + c1777_l1795_action_invoke(&mut instance); + c1778_l1796_action_invoke(&mut instance); + c1779_l1797_action_invoke(&mut instance); + c1780_l1798_action_invoke(&mut instance); + c1781_l1799_action_invoke(&mut instance); + c1782_l1800_action_invoke(&mut instance); + c1783_l1801_action_invoke(&mut instance); + c1784_l1802_action_invoke(&mut instance); + c1785_l1803_action_invoke(&mut instance); + c1786_l1804_action_invoke(&mut instance); + c1787_l1805_action_invoke(&mut instance); + c1788_l1806_action_invoke(&mut instance); + c1789_l1807_action_invoke(&mut instance); + c1790_l1808_action_invoke(&mut instance); + c1791_l1809_action_invoke(&mut instance); + c1792_l1810_action_invoke(&mut instance); + c1793_l1811_assert_return_canonical_nan(&mut instance); + c1794_l1812_assert_return_arithmetic_nan(&mut instance); + c1795_l1813_assert_return_canonical_nan(&mut instance); + c1796_l1814_assert_return_arithmetic_nan(&mut instance); + c1797_l1815_assert_return_canonical_nan(&mut instance); + c1798_l1816_assert_return_arithmetic_nan(&mut instance); + c1799_l1817_assert_return_canonical_nan(&mut instance); + c1800_l1818_assert_return_arithmetic_nan(&mut instance); + c1801_l1819_action_invoke(&mut instance); + c1802_l1820_action_invoke(&mut instance); + c1803_l1821_action_invoke(&mut instance); + c1804_l1822_action_invoke(&mut instance); + c1805_l1823_action_invoke(&mut instance); + c1806_l1824_action_invoke(&mut instance); + c1807_l1825_action_invoke(&mut instance); + c1808_l1826_action_invoke(&mut instance); + c1809_l1827_action_invoke(&mut instance); + c1810_l1828_action_invoke(&mut instance); + c1811_l1829_action_invoke(&mut instance); + c1812_l1830_action_invoke(&mut instance); + c1813_l1831_action_invoke(&mut instance); + c1814_l1832_action_invoke(&mut instance); + c1815_l1833_action_invoke(&mut instance); + c1816_l1834_action_invoke(&mut instance); + c1817_l1835_action_invoke(&mut instance); + c1818_l1836_action_invoke(&mut instance); + c1819_l1837_action_invoke(&mut instance); + c1820_l1838_action_invoke(&mut instance); + c1821_l1839_action_invoke(&mut instance); + c1822_l1840_action_invoke(&mut instance); + c1823_l1841_action_invoke(&mut instance); + c1824_l1842_action_invoke(&mut instance); + c1825_l1843_action_invoke(&mut instance); + c1826_l1844_action_invoke(&mut instance); + c1827_l1845_action_invoke(&mut instance); + c1828_l1846_action_invoke(&mut instance); + c1829_l1847_action_invoke(&mut instance); + c1830_l1848_action_invoke(&mut instance); + c1831_l1849_action_invoke(&mut instance); + c1832_l1850_action_invoke(&mut instance); + c1833_l1851_assert_return_canonical_nan(&mut instance); + c1834_l1852_assert_return_arithmetic_nan(&mut instance); + c1835_l1853_assert_return_canonical_nan(&mut instance); + c1836_l1854_assert_return_arithmetic_nan(&mut instance); + c1837_l1855_assert_return_canonical_nan(&mut instance); + c1838_l1856_assert_return_arithmetic_nan(&mut instance); + c1839_l1857_assert_return_canonical_nan(&mut instance); + c1840_l1858_assert_return_arithmetic_nan(&mut instance); + c1841_l1859_action_invoke(&mut instance); + c1842_l1860_action_invoke(&mut instance); + c1843_l1861_action_invoke(&mut instance); + c1844_l1862_action_invoke(&mut instance); + c1845_l1863_action_invoke(&mut instance); + c1846_l1864_action_invoke(&mut instance); + c1847_l1865_action_invoke(&mut instance); + c1848_l1866_action_invoke(&mut instance); + c1849_l1867_action_invoke(&mut instance); + c1850_l1868_action_invoke(&mut instance); + c1851_l1869_action_invoke(&mut instance); + c1852_l1870_action_invoke(&mut instance); + c1853_l1871_action_invoke(&mut instance); + c1854_l1872_action_invoke(&mut instance); + c1855_l1873_action_invoke(&mut instance); + c1856_l1874_action_invoke(&mut instance); + c1857_l1875_action_invoke(&mut instance); + c1858_l1876_action_invoke(&mut instance); + c1859_l1877_action_invoke(&mut instance); + c1860_l1878_action_invoke(&mut instance); + c1861_l1879_action_invoke(&mut instance); + c1862_l1880_action_invoke(&mut instance); + c1863_l1881_action_invoke(&mut instance); + c1864_l1882_action_invoke(&mut instance); + c1865_l1883_action_invoke(&mut instance); + c1866_l1884_action_invoke(&mut instance); + c1867_l1885_action_invoke(&mut instance); + c1868_l1886_action_invoke(&mut instance); + c1869_l1887_action_invoke(&mut instance); + c1870_l1888_action_invoke(&mut instance); + c1871_l1889_action_invoke(&mut instance); + c1872_l1890_action_invoke(&mut instance); + c1873_l1891_assert_return_canonical_nan(&mut instance); + c1874_l1892_assert_return_arithmetic_nan(&mut instance); + c1875_l1893_assert_return_canonical_nan(&mut instance); + c1876_l1894_assert_return_arithmetic_nan(&mut instance); + c1877_l1895_assert_return_canonical_nan(&mut instance); + c1878_l1896_assert_return_arithmetic_nan(&mut instance); + c1879_l1897_assert_return_canonical_nan(&mut instance); + c1880_l1898_assert_return_arithmetic_nan(&mut instance); + c1881_l1899_action_invoke(&mut instance); + c1882_l1900_action_invoke(&mut instance); + c1883_l1901_action_invoke(&mut instance); + c1884_l1902_action_invoke(&mut instance); + c1885_l1903_action_invoke(&mut instance); + c1886_l1904_action_invoke(&mut instance); + c1887_l1905_action_invoke(&mut instance); + c1888_l1906_action_invoke(&mut instance); + c1889_l1907_action_invoke(&mut instance); + c1890_l1908_action_invoke(&mut instance); + c1891_l1909_action_invoke(&mut instance); + c1892_l1910_action_invoke(&mut instance); + c1893_l1911_action_invoke(&mut instance); + c1894_l1912_action_invoke(&mut instance); + c1895_l1913_action_invoke(&mut instance); + c1896_l1914_action_invoke(&mut instance); + c1897_l1915_action_invoke(&mut instance); + c1898_l1916_action_invoke(&mut instance); + c1899_l1917_action_invoke(&mut instance); + c1900_l1918_action_invoke(&mut instance); + c1901_l1919_action_invoke(&mut instance); + c1902_l1920_action_invoke(&mut instance); + c1903_l1921_action_invoke(&mut instance); + c1904_l1922_action_invoke(&mut instance); + c1905_l1923_action_invoke(&mut instance); + c1906_l1924_action_invoke(&mut instance); + c1907_l1925_action_invoke(&mut instance); + c1908_l1926_action_invoke(&mut instance); + c1909_l1927_action_invoke(&mut instance); + c1910_l1928_action_invoke(&mut instance); + c1911_l1929_action_invoke(&mut instance); + c1912_l1930_action_invoke(&mut instance); + c1913_l1931_assert_return_canonical_nan(&mut instance); + c1914_l1932_assert_return_arithmetic_nan(&mut instance); + c1915_l1933_assert_return_canonical_nan(&mut instance); + c1916_l1934_assert_return_arithmetic_nan(&mut instance); + c1917_l1935_assert_return_canonical_nan(&mut instance); + c1918_l1936_assert_return_arithmetic_nan(&mut instance); + c1919_l1937_assert_return_canonical_nan(&mut instance); + c1920_l1938_assert_return_arithmetic_nan(&mut instance); + c1921_l1939_assert_return_canonical_nan(&mut instance); + c1922_l1940_assert_return_arithmetic_nan(&mut instance); + c1923_l1941_assert_return_canonical_nan(&mut instance); + c1924_l1942_assert_return_arithmetic_nan(&mut instance); + c1925_l1943_assert_return_canonical_nan(&mut instance); + c1926_l1944_assert_return_arithmetic_nan(&mut instance); + c1927_l1945_assert_return_canonical_nan(&mut instance); + c1928_l1946_assert_return_arithmetic_nan(&mut instance); + c1929_l1947_assert_return_canonical_nan(&mut instance); + c1930_l1948_assert_return_arithmetic_nan(&mut instance); + c1931_l1949_assert_return_canonical_nan(&mut instance); + c1932_l1950_assert_return_arithmetic_nan(&mut instance); + c1933_l1951_assert_return_canonical_nan(&mut instance); + c1934_l1952_assert_return_arithmetic_nan(&mut instance); + c1935_l1953_assert_return_canonical_nan(&mut instance); + c1936_l1954_assert_return_arithmetic_nan(&mut instance); + c1937_l1955_assert_return_canonical_nan(&mut instance); + c1938_l1956_assert_return_arithmetic_nan(&mut instance); + c1939_l1957_assert_return_canonical_nan(&mut instance); + c1940_l1958_assert_return_arithmetic_nan(&mut instance); + c1941_l1959_assert_return_canonical_nan(&mut instance); + c1942_l1960_assert_return_arithmetic_nan(&mut instance); + c1943_l1961_assert_return_canonical_nan(&mut instance); + c1944_l1962_assert_return_arithmetic_nan(&mut instance); + c1945_l1963_assert_return_canonical_nan(&mut instance); + c1946_l1964_assert_return_arithmetic_nan(&mut instance); + c1947_l1965_assert_return_canonical_nan(&mut instance); + c1948_l1966_assert_return_arithmetic_nan(&mut instance); + c1949_l1967_assert_return_canonical_nan(&mut instance); + c1950_l1968_assert_return_arithmetic_nan(&mut instance); + c1951_l1969_assert_return_canonical_nan(&mut instance); + c1952_l1970_assert_return_arithmetic_nan(&mut instance); + c1953_l1971_assert_return_canonical_nan(&mut instance); + c1954_l1972_assert_return_arithmetic_nan(&mut instance); + c1955_l1973_assert_return_canonical_nan(&mut instance); + c1956_l1974_assert_return_arithmetic_nan(&mut instance); + c1957_l1975_assert_return_canonical_nan(&mut instance); + c1958_l1976_assert_return_arithmetic_nan(&mut instance); + c1959_l1977_assert_return_canonical_nan(&mut instance); + c1960_l1978_assert_return_arithmetic_nan(&mut instance); + c1961_l1979_assert_return_canonical_nan(&mut instance); + c1962_l1980_assert_return_arithmetic_nan(&mut instance); + c1963_l1981_assert_return_canonical_nan(&mut instance); + c1964_l1982_assert_return_arithmetic_nan(&mut instance); + c1965_l1983_assert_return_canonical_nan(&mut instance); + c1966_l1984_assert_return_arithmetic_nan(&mut instance); + c1967_l1985_assert_return_canonical_nan(&mut instance); + c1968_l1986_assert_return_arithmetic_nan(&mut instance); + c1969_l1987_assert_return_canonical_nan(&mut instance); + c1970_l1988_assert_return_arithmetic_nan(&mut instance); + c1971_l1989_assert_return_canonical_nan(&mut instance); + c1972_l1990_assert_return_arithmetic_nan(&mut instance); + c1973_l1991_assert_return_canonical_nan(&mut instance); + c1974_l1992_assert_return_arithmetic_nan(&mut instance); + c1975_l1993_assert_return_canonical_nan(&mut instance); + c1976_l1994_assert_return_arithmetic_nan(&mut instance); + c1977_l1995_assert_return_canonical_nan(&mut instance); + c1978_l1996_assert_return_arithmetic_nan(&mut instance); + c1979_l1997_assert_return_canonical_nan(&mut instance); + c1980_l1998_assert_return_arithmetic_nan(&mut instance); + c1981_l1999_assert_return_canonical_nan(&mut instance); + c1982_l2000_assert_return_arithmetic_nan(&mut instance); + c1983_l2001_assert_return_canonical_nan(&mut instance); + c1984_l2002_assert_return_arithmetic_nan(&mut instance); + c1985_l2003_assert_return_canonical_nan(&mut instance); + c1986_l2004_assert_return_arithmetic_nan(&mut instance); + c1987_l2005_assert_return_arithmetic_nan(&mut instance); + c1988_l2006_assert_return_arithmetic_nan(&mut instance); + c1989_l2007_assert_return_canonical_nan(&mut instance); + c1990_l2008_assert_return_arithmetic_nan(&mut instance); + c1991_l2009_assert_return_arithmetic_nan(&mut instance); + c1992_l2010_assert_return_arithmetic_nan(&mut instance); + c1993_l2011_assert_return_canonical_nan(&mut instance); + c1994_l2012_assert_return_arithmetic_nan(&mut instance); + c1995_l2013_assert_return_arithmetic_nan(&mut instance); + c1996_l2014_assert_return_arithmetic_nan(&mut instance); + c1997_l2015_assert_return_canonical_nan(&mut instance); + c1998_l2016_assert_return_arithmetic_nan(&mut instance); + c1999_l2017_assert_return_arithmetic_nan(&mut instance); + c2000_l2018_assert_return_arithmetic_nan(&mut instance); + c2001_l2019_action_invoke(&mut instance); + c2002_l2020_action_invoke(&mut instance); + c2003_l2021_action_invoke(&mut instance); + c2004_l2022_action_invoke(&mut instance); + c2005_l2023_action_invoke(&mut instance); + c2006_l2024_action_invoke(&mut instance); + c2007_l2025_action_invoke(&mut instance); + c2008_l2026_action_invoke(&mut instance); + c2009_l2027_action_invoke(&mut instance); + c2010_l2028_action_invoke(&mut instance); + c2011_l2029_action_invoke(&mut instance); + c2012_l2030_action_invoke(&mut instance); + c2013_l2031_action_invoke(&mut instance); + c2014_l2032_action_invoke(&mut instance); + c2015_l2033_action_invoke(&mut instance); + c2016_l2034_action_invoke(&mut instance); + c2017_l2035_action_invoke(&mut instance); + c2018_l2036_action_invoke(&mut instance); + c2019_l2037_action_invoke(&mut instance); + c2020_l2038_action_invoke(&mut instance); + c2021_l2039_action_invoke(&mut instance); + c2022_l2040_action_invoke(&mut instance); + c2023_l2041_action_invoke(&mut instance); + c2024_l2042_action_invoke(&mut instance); + c2025_l2043_action_invoke(&mut instance); + c2026_l2044_action_invoke(&mut instance); + c2027_l2045_action_invoke(&mut instance); + c2028_l2046_action_invoke(&mut instance); + c2029_l2047_action_invoke(&mut instance); + c2030_l2048_action_invoke(&mut instance); + c2031_l2049_action_invoke(&mut instance); + c2032_l2050_action_invoke(&mut instance); + c2033_l2051_assert_return_canonical_nan(&mut instance); + c2034_l2052_assert_return_arithmetic_nan(&mut instance); + c2035_l2053_assert_return_canonical_nan(&mut instance); + c2036_l2054_assert_return_arithmetic_nan(&mut instance); + c2037_l2055_assert_return_canonical_nan(&mut instance); + c2038_l2056_assert_return_arithmetic_nan(&mut instance); + c2039_l2057_assert_return_canonical_nan(&mut instance); + c2040_l2058_assert_return_arithmetic_nan(&mut instance); + c2041_l2059_action_invoke(&mut instance); + c2042_l2060_action_invoke(&mut instance); + c2043_l2061_action_invoke(&mut instance); + c2044_l2062_action_invoke(&mut instance); + c2045_l2063_action_invoke(&mut instance); + c2046_l2064_action_invoke(&mut instance); + c2047_l2065_action_invoke(&mut instance); + c2048_l2066_action_invoke(&mut instance); + c2049_l2067_action_invoke(&mut instance); + c2050_l2068_action_invoke(&mut instance); + c2051_l2069_action_invoke(&mut instance); + c2052_l2070_action_invoke(&mut instance); + c2053_l2071_action_invoke(&mut instance); + c2054_l2072_action_invoke(&mut instance); + c2055_l2073_action_invoke(&mut instance); + c2056_l2074_action_invoke(&mut instance); + c2057_l2075_action_invoke(&mut instance); + c2058_l2076_action_invoke(&mut instance); + c2059_l2077_action_invoke(&mut instance); + c2060_l2078_action_invoke(&mut instance); + c2061_l2079_action_invoke(&mut instance); + c2062_l2080_action_invoke(&mut instance); + c2063_l2081_action_invoke(&mut instance); + c2064_l2082_action_invoke(&mut instance); + c2065_l2083_action_invoke(&mut instance); + c2066_l2084_action_invoke(&mut instance); + c2067_l2085_action_invoke(&mut instance); + c2068_l2086_action_invoke(&mut instance); + c2069_l2087_action_invoke(&mut instance); + c2070_l2088_action_invoke(&mut instance); + c2071_l2089_action_invoke(&mut instance); + c2072_l2090_action_invoke(&mut instance); + c2073_l2091_assert_return_canonical_nan(&mut instance); + c2074_l2092_assert_return_arithmetic_nan(&mut instance); + c2075_l2093_assert_return_canonical_nan(&mut instance); + c2076_l2094_assert_return_arithmetic_nan(&mut instance); + c2077_l2095_assert_return_canonical_nan(&mut instance); + c2078_l2096_assert_return_arithmetic_nan(&mut instance); + c2079_l2097_assert_return_canonical_nan(&mut instance); + c2080_l2098_assert_return_arithmetic_nan(&mut instance); + c2081_l2099_action_invoke(&mut instance); + c2082_l2100_action_invoke(&mut instance); + c2083_l2101_action_invoke(&mut instance); + c2084_l2102_action_invoke(&mut instance); + c2085_l2103_action_invoke(&mut instance); + c2086_l2104_action_invoke(&mut instance); + c2087_l2105_action_invoke(&mut instance); + c2088_l2106_action_invoke(&mut instance); + c2089_l2107_action_invoke(&mut instance); + c2090_l2108_action_invoke(&mut instance); + c2091_l2109_action_invoke(&mut instance); + c2092_l2110_action_invoke(&mut instance); + c2093_l2111_action_invoke(&mut instance); + c2094_l2112_action_invoke(&mut instance); + c2095_l2113_action_invoke(&mut instance); + c2096_l2114_action_invoke(&mut instance); + c2097_l2115_action_invoke(&mut instance); + c2098_l2116_action_invoke(&mut instance); + c2099_l2117_action_invoke(&mut instance); + c2100_l2118_action_invoke(&mut instance); + c2101_l2119_action_invoke(&mut instance); + c2102_l2120_action_invoke(&mut instance); + c2103_l2121_action_invoke(&mut instance); + c2104_l2122_action_invoke(&mut instance); + c2105_l2123_action_invoke(&mut instance); + c2106_l2124_action_invoke(&mut instance); + c2107_l2125_action_invoke(&mut instance); + c2108_l2126_action_invoke(&mut instance); + c2109_l2127_action_invoke(&mut instance); + c2110_l2128_action_invoke(&mut instance); + c2111_l2129_action_invoke(&mut instance); + c2112_l2130_action_invoke(&mut instance); + c2113_l2131_assert_return_canonical_nan(&mut instance); + c2114_l2132_assert_return_arithmetic_nan(&mut instance); + c2115_l2133_assert_return_canonical_nan(&mut instance); + c2116_l2134_assert_return_arithmetic_nan(&mut instance); + c2117_l2135_assert_return_canonical_nan(&mut instance); + c2118_l2136_assert_return_arithmetic_nan(&mut instance); + c2119_l2137_assert_return_canonical_nan(&mut instance); + c2120_l2138_assert_return_arithmetic_nan(&mut instance); + c2121_l2139_action_invoke(&mut instance); + c2122_l2140_action_invoke(&mut instance); + c2123_l2141_action_invoke(&mut instance); + c2124_l2142_action_invoke(&mut instance); + c2125_l2143_action_invoke(&mut instance); + c2126_l2144_action_invoke(&mut instance); + c2127_l2145_action_invoke(&mut instance); + c2128_l2146_action_invoke(&mut instance); + c2129_l2147_action_invoke(&mut instance); + c2130_l2148_action_invoke(&mut instance); + c2131_l2149_action_invoke(&mut instance); + c2132_l2150_action_invoke(&mut instance); + c2133_l2151_action_invoke(&mut instance); + c2134_l2152_action_invoke(&mut instance); + c2135_l2153_action_invoke(&mut instance); + c2136_l2154_action_invoke(&mut instance); + c2137_l2155_action_invoke(&mut instance); + c2138_l2156_action_invoke(&mut instance); + c2139_l2157_action_invoke(&mut instance); + c2140_l2158_action_invoke(&mut instance); + c2141_l2159_action_invoke(&mut instance); + c2142_l2160_action_invoke(&mut instance); + c2143_l2161_action_invoke(&mut instance); + c2144_l2162_action_invoke(&mut instance); + c2145_l2163_action_invoke(&mut instance); + c2146_l2164_action_invoke(&mut instance); + c2147_l2165_action_invoke(&mut instance); + c2148_l2166_action_invoke(&mut instance); + c2149_l2167_action_invoke(&mut instance); + c2150_l2168_action_invoke(&mut instance); + c2151_l2169_action_invoke(&mut instance); + c2152_l2170_action_invoke(&mut instance); + c2153_l2171_assert_return_canonical_nan(&mut instance); + c2154_l2172_assert_return_arithmetic_nan(&mut instance); + c2155_l2173_assert_return_canonical_nan(&mut instance); + c2156_l2174_assert_return_arithmetic_nan(&mut instance); + c2157_l2175_assert_return_canonical_nan(&mut instance); + c2158_l2176_assert_return_arithmetic_nan(&mut instance); + c2159_l2177_assert_return_canonical_nan(&mut instance); + c2160_l2178_assert_return_arithmetic_nan(&mut instance); + c2161_l2179_action_invoke(&mut instance); + c2162_l2180_action_invoke(&mut instance); + c2163_l2181_action_invoke(&mut instance); + c2164_l2182_action_invoke(&mut instance); + c2165_l2183_action_invoke(&mut instance); + c2166_l2184_action_invoke(&mut instance); + c2167_l2185_action_invoke(&mut instance); + c2168_l2186_action_invoke(&mut instance); + c2169_l2187_action_invoke(&mut instance); + c2170_l2188_action_invoke(&mut instance); + c2171_l2189_action_invoke(&mut instance); + c2172_l2190_action_invoke(&mut instance); + c2173_l2191_action_invoke(&mut instance); + c2174_l2192_action_invoke(&mut instance); + c2175_l2193_action_invoke(&mut instance); + c2176_l2194_action_invoke(&mut instance); + c2177_l2195_action_invoke(&mut instance); + c2178_l2196_action_invoke(&mut instance); + c2179_l2197_action_invoke(&mut instance); + c2180_l2198_action_invoke(&mut instance); + c2181_l2199_action_invoke(&mut instance); + c2182_l2200_action_invoke(&mut instance); + c2183_l2201_action_invoke(&mut instance); + c2184_l2202_action_invoke(&mut instance); + c2185_l2203_action_invoke(&mut instance); + c2186_l2204_action_invoke(&mut instance); + c2187_l2205_action_invoke(&mut instance); + c2188_l2206_action_invoke(&mut instance); + c2189_l2207_action_invoke(&mut instance); + c2190_l2208_action_invoke(&mut instance); + c2191_l2209_action_invoke(&mut instance); + c2192_l2210_action_invoke(&mut instance); + c2193_l2211_assert_return_canonical_nan(&mut instance); + c2194_l2212_assert_return_arithmetic_nan(&mut instance); + c2195_l2213_assert_return_canonical_nan(&mut instance); + c2196_l2214_assert_return_arithmetic_nan(&mut instance); + c2197_l2215_assert_return_canonical_nan(&mut instance); + c2198_l2216_assert_return_arithmetic_nan(&mut instance); + c2199_l2217_assert_return_canonical_nan(&mut instance); + c2200_l2218_assert_return_arithmetic_nan(&mut instance); + c2201_l2219_action_invoke(&mut instance); + c2202_l2220_action_invoke(&mut instance); + c2203_l2221_action_invoke(&mut instance); + c2204_l2222_action_invoke(&mut instance); + c2205_l2223_action_invoke(&mut instance); + c2206_l2224_action_invoke(&mut instance); + c2207_l2225_action_invoke(&mut instance); + c2208_l2226_action_invoke(&mut instance); + c2209_l2227_action_invoke(&mut instance); + c2210_l2228_action_invoke(&mut instance); + c2211_l2229_action_invoke(&mut instance); + c2212_l2230_action_invoke(&mut instance); + c2213_l2231_action_invoke(&mut instance); + c2214_l2232_action_invoke(&mut instance); + c2215_l2233_action_invoke(&mut instance); + c2216_l2234_action_invoke(&mut instance); + c2217_l2235_action_invoke(&mut instance); + c2218_l2236_action_invoke(&mut instance); + c2219_l2237_action_invoke(&mut instance); + c2220_l2238_action_invoke(&mut instance); + c2221_l2239_action_invoke(&mut instance); + c2222_l2240_action_invoke(&mut instance); + c2223_l2241_action_invoke(&mut instance); + c2224_l2242_action_invoke(&mut instance); + c2225_l2243_action_invoke(&mut instance); + c2226_l2244_action_invoke(&mut instance); + c2227_l2245_action_invoke(&mut instance); + c2228_l2246_action_invoke(&mut instance); + c2229_l2247_action_invoke(&mut instance); + c2230_l2248_action_invoke(&mut instance); + c2231_l2249_action_invoke(&mut instance); + c2232_l2250_action_invoke(&mut instance); + c2233_l2251_assert_return_canonical_nan(&mut instance); + c2234_l2252_assert_return_arithmetic_nan(&mut instance); + c2235_l2253_assert_return_canonical_nan(&mut instance); + c2236_l2254_assert_return_arithmetic_nan(&mut instance); + c2237_l2255_assert_return_canonical_nan(&mut instance); + c2238_l2256_assert_return_arithmetic_nan(&mut instance); + c2239_l2257_assert_return_canonical_nan(&mut instance); + c2240_l2258_assert_return_arithmetic_nan(&mut instance); + c2241_l2259_action_invoke(&mut instance); + c2242_l2260_action_invoke(&mut instance); + c2243_l2261_action_invoke(&mut instance); + c2244_l2262_action_invoke(&mut instance); + c2245_l2263_action_invoke(&mut instance); + c2246_l2264_action_invoke(&mut instance); + c2247_l2265_action_invoke(&mut instance); + c2248_l2266_action_invoke(&mut instance); + c2249_l2267_action_invoke(&mut instance); + c2250_l2268_action_invoke(&mut instance); + c2251_l2269_action_invoke(&mut instance); + c2252_l2270_action_invoke(&mut instance); + c2253_l2271_action_invoke(&mut instance); + c2254_l2272_action_invoke(&mut instance); + c2255_l2273_action_invoke(&mut instance); + c2256_l2274_action_invoke(&mut instance); + c2257_l2275_action_invoke(&mut instance); + c2258_l2276_action_invoke(&mut instance); + c2259_l2277_action_invoke(&mut instance); + c2260_l2278_action_invoke(&mut instance); + c2261_l2279_action_invoke(&mut instance); + c2262_l2280_action_invoke(&mut instance); + c2263_l2281_action_invoke(&mut instance); + c2264_l2282_action_invoke(&mut instance); + c2265_l2283_action_invoke(&mut instance); + c2266_l2284_action_invoke(&mut instance); + c2267_l2285_action_invoke(&mut instance); + c2268_l2286_action_invoke(&mut instance); + c2269_l2287_action_invoke(&mut instance); + c2270_l2288_action_invoke(&mut instance); + c2271_l2289_action_invoke(&mut instance); + c2272_l2290_action_invoke(&mut instance); + c2273_l2291_assert_return_canonical_nan(&mut instance); + c2274_l2292_assert_return_arithmetic_nan(&mut instance); + c2275_l2293_assert_return_canonical_nan(&mut instance); + c2276_l2294_assert_return_arithmetic_nan(&mut instance); + c2277_l2295_assert_return_canonical_nan(&mut instance); + c2278_l2296_assert_return_arithmetic_nan(&mut instance); + c2279_l2297_assert_return_canonical_nan(&mut instance); + c2280_l2298_assert_return_arithmetic_nan(&mut instance); + c2281_l2299_action_invoke(&mut instance); + c2282_l2300_action_invoke(&mut instance); + c2283_l2301_action_invoke(&mut instance); + c2284_l2302_action_invoke(&mut instance); + c2285_l2303_action_invoke(&mut instance); + c2286_l2304_action_invoke(&mut instance); + c2287_l2305_action_invoke(&mut instance); + c2288_l2306_action_invoke(&mut instance); + c2289_l2307_action_invoke(&mut instance); + c2290_l2308_action_invoke(&mut instance); + c2291_l2309_action_invoke(&mut instance); + c2292_l2310_action_invoke(&mut instance); + c2293_l2311_action_invoke(&mut instance); + c2294_l2312_action_invoke(&mut instance); + c2295_l2313_action_invoke(&mut instance); + c2296_l2314_action_invoke(&mut instance); + c2297_l2315_action_invoke(&mut instance); + c2298_l2316_action_invoke(&mut instance); + c2299_l2317_action_invoke(&mut instance); + c2300_l2318_action_invoke(&mut instance); + c2301_l2319_action_invoke(&mut instance); + c2302_l2320_action_invoke(&mut instance); + c2303_l2321_action_invoke(&mut instance); + c2304_l2322_action_invoke(&mut instance); + c2305_l2323_action_invoke(&mut instance); + c2306_l2324_action_invoke(&mut instance); + c2307_l2325_action_invoke(&mut instance); + c2308_l2326_action_invoke(&mut instance); + c2309_l2327_action_invoke(&mut instance); + c2310_l2328_action_invoke(&mut instance); + c2311_l2329_action_invoke(&mut instance); + c2312_l2330_action_invoke(&mut instance); + c2313_l2331_assert_return_canonical_nan(&mut instance); + c2314_l2332_assert_return_arithmetic_nan(&mut instance); + c2315_l2333_assert_return_canonical_nan(&mut instance); + c2316_l2334_assert_return_arithmetic_nan(&mut instance); + c2317_l2335_assert_return_canonical_nan(&mut instance); + c2318_l2336_assert_return_arithmetic_nan(&mut instance); + c2319_l2337_assert_return_canonical_nan(&mut instance); + c2320_l2338_assert_return_arithmetic_nan(&mut instance); + c2321_l2339_assert_return_canonical_nan(&mut instance); + c2322_l2340_assert_return_arithmetic_nan(&mut instance); + c2323_l2341_assert_return_canonical_nan(&mut instance); + c2324_l2342_assert_return_arithmetic_nan(&mut instance); + c2325_l2343_assert_return_canonical_nan(&mut instance); + c2326_l2344_assert_return_arithmetic_nan(&mut instance); + c2327_l2345_assert_return_canonical_nan(&mut instance); + c2328_l2346_assert_return_arithmetic_nan(&mut instance); + c2329_l2347_assert_return_canonical_nan(&mut instance); + c2330_l2348_assert_return_arithmetic_nan(&mut instance); + c2331_l2349_assert_return_canonical_nan(&mut instance); + c2332_l2350_assert_return_arithmetic_nan(&mut instance); + c2333_l2351_assert_return_canonical_nan(&mut instance); + c2334_l2352_assert_return_arithmetic_nan(&mut instance); + c2335_l2353_assert_return_canonical_nan(&mut instance); + c2336_l2354_assert_return_arithmetic_nan(&mut instance); + c2337_l2355_assert_return_canonical_nan(&mut instance); + c2338_l2356_assert_return_arithmetic_nan(&mut instance); + c2339_l2357_assert_return_canonical_nan(&mut instance); + c2340_l2358_assert_return_arithmetic_nan(&mut instance); + c2341_l2359_assert_return_canonical_nan(&mut instance); + c2342_l2360_assert_return_arithmetic_nan(&mut instance); + c2343_l2361_assert_return_canonical_nan(&mut instance); + c2344_l2362_assert_return_arithmetic_nan(&mut instance); + c2345_l2363_assert_return_canonical_nan(&mut instance); + c2346_l2364_assert_return_arithmetic_nan(&mut instance); + c2347_l2365_assert_return_canonical_nan(&mut instance); + c2348_l2366_assert_return_arithmetic_nan(&mut instance); + c2349_l2367_assert_return_canonical_nan(&mut instance); + c2350_l2368_assert_return_arithmetic_nan(&mut instance); + c2351_l2369_assert_return_canonical_nan(&mut instance); + c2352_l2370_assert_return_arithmetic_nan(&mut instance); + c2353_l2371_assert_return_canonical_nan(&mut instance); + c2354_l2372_assert_return_arithmetic_nan(&mut instance); + c2355_l2373_assert_return_canonical_nan(&mut instance); + c2356_l2374_assert_return_arithmetic_nan(&mut instance); + c2357_l2375_assert_return_canonical_nan(&mut instance); + c2358_l2376_assert_return_arithmetic_nan(&mut instance); + c2359_l2377_assert_return_canonical_nan(&mut instance); + c2360_l2378_assert_return_arithmetic_nan(&mut instance); + c2361_l2379_assert_return_canonical_nan(&mut instance); + c2362_l2380_assert_return_arithmetic_nan(&mut instance); + c2363_l2381_assert_return_canonical_nan(&mut instance); + c2364_l2382_assert_return_arithmetic_nan(&mut instance); + c2365_l2383_assert_return_canonical_nan(&mut instance); + c2366_l2384_assert_return_arithmetic_nan(&mut instance); + c2367_l2385_assert_return_canonical_nan(&mut instance); + c2368_l2386_assert_return_arithmetic_nan(&mut instance); + c2369_l2387_assert_return_canonical_nan(&mut instance); + c2370_l2388_assert_return_arithmetic_nan(&mut instance); + c2371_l2389_assert_return_canonical_nan(&mut instance); + c2372_l2390_assert_return_arithmetic_nan(&mut instance); + c2373_l2391_assert_return_canonical_nan(&mut instance); + c2374_l2392_assert_return_arithmetic_nan(&mut instance); + c2375_l2393_assert_return_canonical_nan(&mut instance); + c2376_l2394_assert_return_arithmetic_nan(&mut instance); + c2377_l2395_assert_return_canonical_nan(&mut instance); + c2378_l2396_assert_return_arithmetic_nan(&mut instance); + c2379_l2397_assert_return_canonical_nan(&mut instance); + c2380_l2398_assert_return_arithmetic_nan(&mut instance); + c2381_l2399_assert_return_canonical_nan(&mut instance); + c2382_l2400_assert_return_arithmetic_nan(&mut instance); + c2383_l2401_assert_return_canonical_nan(&mut instance); + c2384_l2402_assert_return_arithmetic_nan(&mut instance); + c2385_l2403_assert_return_canonical_nan(&mut instance); + c2386_l2404_assert_return_arithmetic_nan(&mut instance); + c2387_l2405_assert_return_arithmetic_nan(&mut instance); + c2388_l2406_assert_return_arithmetic_nan(&mut instance); + c2389_l2407_assert_return_canonical_nan(&mut instance); + c2390_l2408_assert_return_arithmetic_nan(&mut instance); + c2391_l2409_assert_return_arithmetic_nan(&mut instance); + c2392_l2410_assert_return_arithmetic_nan(&mut instance); + c2393_l2411_assert_return_canonical_nan(&mut instance); + c2394_l2412_assert_return_arithmetic_nan(&mut instance); + c2395_l2413_assert_return_arithmetic_nan(&mut instance); + c2396_l2414_assert_return_arithmetic_nan(&mut instance); + c2397_l2415_assert_return_canonical_nan(&mut instance); + c2398_l2416_assert_return_arithmetic_nan(&mut instance); + c2399_l2417_assert_return_arithmetic_nan(&mut instance); + c2400_l2418_assert_return_arithmetic_nan(&mut instance); + c2401_l2419_action_invoke(&mut instance); + c2402_l2420_action_invoke(&mut instance); + c2403_l2421_assert_return_canonical_nan(&mut instance); + c2404_l2422_action_invoke(&mut instance); + c2405_l2423_assert_return_canonical_nan(&mut instance); + c2406_l2424_action_invoke(&mut instance); + c2407_l2425_assert_return_canonical_nan(&mut instance); + c2408_l2426_action_invoke(&mut instance); + c2409_l2427_assert_return_canonical_nan(&mut instance); + c2410_l2428_action_invoke(&mut instance); + c2411_l2429_assert_return_canonical_nan(&mut instance); + c2412_l2430_action_invoke(&mut instance); + c2413_l2431_assert_return_canonical_nan(&mut instance); + c2414_l2432_action_invoke(&mut instance); + c2415_l2433_assert_return_canonical_nan(&mut instance); + c2416_l2434_action_invoke(&mut instance); + c2417_l2435_assert_return_canonical_nan(&mut instance); + c2418_l2436_assert_return_arithmetic_nan(&mut instance); + c2419_l2437_assert_return_canonical_nan(&mut instance); + c2420_l2438_assert_return_arithmetic_nan(&mut instance); + c2421_l2439_action_invoke(&mut instance); + c2422_l2440_action_invoke(&mut instance); + c2423_l2441_action_invoke(&mut instance); + c2424_l2442_action_invoke(&mut instance); + c2425_l2443_action_invoke(&mut instance); + c2426_l2444_action_invoke(&mut instance); + c2427_l2445_action_invoke(&mut instance); + c2428_l2446_action_invoke(&mut instance); + c2429_l2447_action_invoke(&mut instance); + c2430_l2448_action_invoke(&mut instance); + c2431_l2449_action_invoke(&mut instance); + c2432_l2450_action_invoke(&mut instance); + c2433_l2451_action_invoke(&mut instance); + c2434_l2452_action_invoke(&mut instance); + c2435_l2453_action_invoke(&mut instance); + c2436_l2454_action_invoke(&mut instance); + c2437_l2455_assert_return_canonical_nan(&mut instance); + c2438_l2456_assert_return_arithmetic_nan(&mut instance); + c2439_l2457_assert_return_canonical_nan(&mut instance); + c2440_l2458_assert_return_arithmetic_nan(&mut instance); + c2441_l2459_action_invoke(&mut instance); + c2442_l2460_action_invoke(&mut instance); + c2443_l2461_action_invoke(&mut instance); + c2444_l2462_action_invoke(&mut instance); + c2445_l2463_action_invoke(&mut instance); + c2446_l2464_action_invoke(&mut instance); + c2447_l2465_action_invoke(&mut instance); + c2448_l2466_action_invoke(&mut instance); + c2449_l2467_action_invoke(&mut instance); + c2450_l2468_action_invoke(&mut instance); + c2451_l2469_action_invoke(&mut instance); + c2452_l2470_action_invoke(&mut instance); + c2453_l2471_action_invoke(&mut instance); + c2454_l2472_action_invoke(&mut instance); + c2455_l2473_action_invoke(&mut instance); + c2456_l2474_action_invoke(&mut instance); + c2457_l2475_assert_return_canonical_nan(&mut instance); + c2458_l2476_assert_return_arithmetic_nan(&mut instance); + c2459_l2477_assert_return_canonical_nan(&mut instance); + c2460_l2478_assert_return_arithmetic_nan(&mut instance); + c2461_l2479_action_invoke(&mut instance); + c2462_l2480_action_invoke(&mut instance); + c2463_l2481_action_invoke(&mut instance); + c2464_l2482_action_invoke(&mut instance); + c2465_l2483_action_invoke(&mut instance); + c2466_l2484_action_invoke(&mut instance); + c2467_l2485_action_invoke(&mut instance); + c2468_l2486_action_invoke(&mut instance); + c2469_l2487_action_invoke(&mut instance); + c2470_l2488_action_invoke(&mut instance); + c2471_l2489_action_invoke(&mut instance); + c2472_l2490_action_invoke(&mut instance); + c2473_l2491_action_invoke(&mut instance); + c2474_l2492_action_invoke(&mut instance); + c2475_l2493_action_invoke(&mut instance); + c2476_l2494_action_invoke(&mut instance); + c2477_l2495_assert_return_canonical_nan(&mut instance); + c2478_l2496_assert_return_arithmetic_nan(&mut instance); + c2479_l2497_assert_return_canonical_nan(&mut instance); + c2480_l2498_assert_return_arithmetic_nan(&mut instance); + c2481_l2499_action_invoke(&mut instance); + c2482_l2500_action_invoke(&mut instance); + c2483_l2501_action_invoke(&mut instance); + c2484_l2502_action_invoke(&mut instance); + c2485_l2503_action_invoke(&mut instance); + c2486_l2504_action_invoke(&mut instance); + c2487_l2505_action_invoke(&mut instance); + c2488_l2506_action_invoke(&mut instance); + c2489_l2507_action_invoke(&mut instance); + c2490_l2508_action_invoke(&mut instance); + c2491_l2509_action_invoke(&mut instance); + c2492_l2510_action_invoke(&mut instance); + c2493_l2511_action_invoke(&mut instance); + c2494_l2512_action_invoke(&mut instance); + c2495_l2513_action_invoke(&mut instance); + c2496_l2514_action_invoke(&mut instance); + c2497_l2515_assert_return_canonical_nan(&mut instance); + c2498_l2516_assert_return_arithmetic_nan(&mut instance); + c2499_l2517_assert_return_canonical_nan(&mut instance); + c2500_l2518_assert_return_arithmetic_nan(&mut instance); +} diff --git a/lib/runtime/tests/spectests/f32_bitwise.rs b/lib/runtime/tests/spectests/f32_bitwise.rs new file mode 100644 index 000000000..904ca0919 --- /dev/null +++ b/lib/runtime/tests/spectests/f32_bitwise.rs @@ -0,0 +1,3535 @@ +// 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}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 4 +fn create_module_1() -> Box { + 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); +} diff --git a/lib/runtime/tests/spectests/f32_cmp.rs b/lib/runtime/tests/spectests/f32_cmp.rs new file mode 100644 index 000000000..94fa70b87 --- /dev/null +++ b/lib/runtime/tests/spectests/f32_cmp.rs @@ -0,0 +1,21671 @@ +// 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_cmp.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 4 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32) (result i32))) + (func (;0;) (type 0) (param f32 f32) (result i32) + get_local 0 + get_local 1 + f32.eq) + (func (;1;) (type 0) (param f32 f32) (result i32) + get_local 0 + get_local 1 + f32.ne) + (func (;2;) (type 0) (param f32 f32) (result i32) + get_local 0 + get_local 1 + f32.lt) + (func (;3;) (type 0) (param f32 f32) (result i32) + get_local 0 + get_local 1 + f32.le) + (func (;4;) (type 0) (param f32 f32) (result i32) + get_local 0 + get_local 1 + f32.gt) + (func (;5;) (type 0) (param f32 f32) (result i32) + get_local 0 + get_local 1 + f32.ge) + (export \"eq\" (func 0)) + (export \"ne\" (func 1)) + (export \"lt\" (func 2)) + (export \"le\" (func 3)) + (export \"gt\" (func 4)) + (export \"ge\" (func 5))) + "; + 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 13 +fn c1_l13_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l13_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 14 +fn c2_l14_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l14_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 15 +fn c3_l15_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l15_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 16 +fn c4_l16_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l16_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 17 +fn c5_l17_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l17_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 18 +fn c6_l18_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l18_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 19 +fn c7_l19_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l19_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 20 +fn c8_l20_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l20_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 21 +fn c9_l21_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l21_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 22 +fn c10_l22_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c10_l22_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 23 +fn c11_l23_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c11_l23_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 24 +fn c12_l24_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c12_l24_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 25 +fn c13_l25_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c13_l25_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 26 +fn c14_l26_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c14_l26_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 27 +fn c15_l27_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c15_l27_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 28 +fn c16_l28_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c16_l28_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 29 +fn c17_l29_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c17_l29_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 30 +fn c18_l30_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c18_l30_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 31 +fn c19_l31_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c19_l31_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 32 +fn c20_l32_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c20_l32_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 33 +fn c21_l33_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c21_l33_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 34 +fn c22_l34_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c22_l34_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 35 +fn c23_l35_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c23_l35_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 36 +fn c24_l36_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c24_l36_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 37 +fn c25_l37_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c25_l37_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 38 +fn c26_l38_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c26_l38_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 39 +fn c27_l39_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c27_l39_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 40 +fn c28_l40_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c28_l40_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 41 +fn c29_l41_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c29_l41_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 42 +fn c30_l42_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c30_l42_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 43 +fn c31_l43_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c31_l43_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 44 +fn c32_l44_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c32_l44_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 45 +fn c33_l45_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c33_l45_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 46 +fn c34_l46_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c34_l46_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 47 +fn c35_l47_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c35_l47_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 48 +fn c36_l48_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c36_l48_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 49 +fn c37_l49_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c37_l49_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 50 +fn c38_l50_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c38_l50_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 51 +fn c39_l51_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c39_l51_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 52 +fn c40_l52_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c40_l52_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 53 +fn c41_l53_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c41_l53_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 54 +fn c42_l54_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c42_l54_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 55 +fn c43_l55_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c43_l55_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 56 +fn c44_l56_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c44_l56_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 57 +fn c45_l57_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c45_l57_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 58 +fn c46_l58_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c46_l58_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 59 +fn c47_l59_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c47_l59_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 60 +fn c48_l60_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c48_l60_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 61 +fn c49_l61_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c49_l61_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 62 +fn c50_l62_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c50_l62_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 63 +fn c51_l63_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c51_l63_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 64 +fn c52_l64_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c52_l64_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 65 +fn c53_l65_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c53_l65_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 66 +fn c54_l66_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c54_l66_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 67 +fn c55_l67_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c55_l67_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 68 +fn c56_l68_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c56_l68_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 69 +fn c57_l69_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c57_l69_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 70 +fn c58_l70_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c58_l70_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 71 +fn c59_l71_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c59_l71_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 72 +fn c60_l72_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c60_l72_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 73 +fn c61_l73_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c61_l73_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 74 +fn c62_l74_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c62_l74_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 75 +fn c63_l75_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c63_l75_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 76 +fn c64_l76_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c64_l76_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 77 +fn c65_l77_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c65_l77_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 78 +fn c66_l78_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c66_l78_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 79 +fn c67_l79_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c67_l79_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 80 +fn c68_l80_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c68_l80_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 81 +fn c69_l81_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c69_l81_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 82 +fn c70_l82_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c70_l82_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 83 +fn c71_l83_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c71_l83_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 84 +fn c72_l84_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c72_l84_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 85 +fn c73_l85_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c73_l85_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 86 +fn c74_l86_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c74_l86_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 87 +fn c75_l87_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c75_l87_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 88 +fn c76_l88_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c76_l88_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 89 +fn c77_l89_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c77_l89_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 90 +fn c78_l90_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c78_l90_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 91 +fn c79_l91_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c79_l91_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 92 +fn c80_l92_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c80_l92_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 93 +fn c81_l93_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c81_l93_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 94 +fn c82_l94_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c82_l94_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 95 +fn c83_l95_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c83_l95_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 96 +fn c84_l96_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c84_l96_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 97 +fn c85_l97_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c85_l97_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 98 +fn c86_l98_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c86_l98_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 99 +fn c87_l99_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c87_l99_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 100 +fn c88_l100_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c88_l100_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 101 +fn c89_l101_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c89_l101_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 102 +fn c90_l102_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c90_l102_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 103 +fn c91_l103_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c91_l103_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 104 +fn c92_l104_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c92_l104_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 105 +fn c93_l105_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c93_l105_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 106 +fn c94_l106_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c94_l106_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 107 +fn c95_l107_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c95_l107_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 108 +fn c96_l108_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c96_l108_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 109 +fn c97_l109_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c97_l109_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 110 +fn c98_l110_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c98_l110_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 111 +fn c99_l111_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c99_l111_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 112 +fn c100_l112_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c100_l112_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 113 +fn c101_l113_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c101_l113_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 114 +fn c102_l114_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c102_l114_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 115 +fn c103_l115_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c103_l115_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 116 +fn c104_l116_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c104_l116_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 117 +fn c105_l117_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c105_l117_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 118 +fn c106_l118_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c106_l118_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 119 +fn c107_l119_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c107_l119_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 120 +fn c108_l120_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c108_l120_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 121 +fn c109_l121_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c109_l121_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 122 +fn c110_l122_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c110_l122_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 123 +fn c111_l123_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c111_l123_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 124 +fn c112_l124_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c112_l124_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 125 +fn c113_l125_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c113_l125_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 126 +fn c114_l126_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c114_l126_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 127 +fn c115_l127_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c115_l127_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 128 +fn c116_l128_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c116_l128_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 129 +fn c117_l129_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c117_l129_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 130 +fn c118_l130_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c118_l130_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 131 +fn c119_l131_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c119_l131_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 132 +fn c120_l132_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c120_l132_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 133 +fn c121_l133_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c121_l133_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 134 +fn c122_l134_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c122_l134_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 135 +fn c123_l135_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c123_l135_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 136 +fn c124_l136_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c124_l136_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.5f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 137 +fn c125_l137_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c125_l137_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 138 +fn c126_l138_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c126_l138_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 139 +fn c127_l139_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c127_l139_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 140 +fn c128_l140_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c128_l140_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 141 +fn c129_l141_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c129_l141_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 142 +fn c130_l142_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c130_l142_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 143 +fn c131_l143_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c131_l143_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 144 +fn c132_l144_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c132_l144_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 145 +fn c133_l145_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c133_l145_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 146 +fn c134_l146_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c134_l146_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 147 +fn c135_l147_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c135_l147_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 148 +fn c136_l148_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c136_l148_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.5f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 149 +fn c137_l149_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c137_l149_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.5f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 150 +fn c138_l150_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c138_l150_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.5f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 151 +fn c139_l151_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c139_l151_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.5f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 152 +fn c140_l152_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c140_l152_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.5f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 153 +fn c141_l153_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c141_l153_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.5f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 154 +fn c142_l154_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c142_l154_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.5f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 155 +fn c143_l155_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c143_l155_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.5f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 156 +fn c144_l156_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c144_l156_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.5f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 157 +fn c145_l157_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c145_l157_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.5f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 158 +fn c146_l158_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c146_l158_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.5f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 159 +fn c147_l159_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c147_l159_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.5f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 160 +fn c148_l160_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c148_l160_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.5f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 161 +fn c149_l161_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c149_l161_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 162 +fn c150_l162_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c150_l162_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 163 +fn c151_l163_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c151_l163_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 164 +fn c152_l164_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c152_l164_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 165 +fn c153_l165_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c153_l165_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 166 +fn c154_l166_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c154_l166_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 167 +fn c155_l167_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c155_l167_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 168 +fn c156_l168_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c156_l168_action_invoke"); + let result = instance.call("eq", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 169 +fn c157_l169_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c157_l169_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 170 +fn c158_l170_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c158_l170_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 171 +fn c159_l171_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c159_l171_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 172 +fn c160_l172_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c160_l172_action_invoke"); + let result = instance.call("eq", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 173 +fn c161_l173_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c161_l173_action_invoke"); + let result = instance.call("eq", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 174 +fn c162_l174_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c162_l174_action_invoke"); + let result = instance.call("eq", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 175 +fn c163_l175_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c163_l175_action_invoke"); + let result = instance.call("eq", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 176 +fn c164_l176_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c164_l176_action_invoke"); + let result = instance.call("eq", &[Value::F32((1.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 177 +fn c165_l177_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c165_l177_action_invoke"); + let result = instance.call("eq", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 178 +fn c166_l178_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c166_l178_action_invoke"); + let result = instance.call("eq", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 179 +fn c167_l179_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c167_l179_action_invoke"); + let result = instance.call("eq", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 180 +fn c168_l180_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c168_l180_action_invoke"); + let result = instance.call("eq", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 181 +fn c169_l181_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c169_l181_action_invoke"); + let result = instance.call("eq", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 182 +fn c170_l182_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c170_l182_action_invoke"); + let result = instance.call("eq", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 183 +fn c171_l183_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c171_l183_action_invoke"); + let result = instance.call("eq", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 184 +fn c172_l184_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c172_l184_action_invoke"); + let result = instance.call("eq", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 185 +fn c173_l185_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c173_l185_action_invoke"); + let result = instance.call("eq", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 186 +fn c174_l186_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c174_l186_action_invoke"); + let result = instance.call("eq", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 187 +fn c175_l187_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c175_l187_action_invoke"); + let result = instance.call("eq", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 188 +fn c176_l188_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c176_l188_action_invoke"); + let result = instance.call("eq", &[Value::F32((1.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 189 +fn c177_l189_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c177_l189_action_invoke"); + let result = instance.call("eq", &[Value::F32((-1.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 190 +fn c178_l190_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c178_l190_action_invoke"); + let result = instance.call("eq", &[Value::F32((-1.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 191 +fn c179_l191_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c179_l191_action_invoke"); + let result = instance.call("eq", &[Value::F32((1.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 192 +fn c180_l192_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c180_l192_action_invoke"); + let result = instance.call("eq", &[Value::F32((1.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 193 +fn c181_l193_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c181_l193_action_invoke"); + let result = instance.call("eq", &[Value::F32((-1.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 194 +fn c182_l194_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c182_l194_action_invoke"); + let result = instance.call("eq", &[Value::F32((-1.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 195 +fn c183_l195_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c183_l195_action_invoke"); + let result = instance.call("eq", &[Value::F32((1.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 196 +fn c184_l196_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c184_l196_action_invoke"); + let result = instance.call("eq", &[Value::F32((1.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 197 +fn c185_l197_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c185_l197_action_invoke"); + let result = instance.call("eq", &[Value::F32((-1.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 198 +fn c186_l198_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c186_l198_action_invoke"); + let result = instance.call("eq", &[Value::F32((-1.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 199 +fn c187_l199_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c187_l199_action_invoke"); + let result = instance.call("eq", &[Value::F32((1.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 200 +fn c188_l200_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c188_l200_action_invoke"); + let result = instance.call("eq", &[Value::F32((1.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 201 +fn c189_l201_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c189_l201_action_invoke"); + let result = instance.call("eq", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 202 +fn c190_l202_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c190_l202_action_invoke"); + let result = instance.call("eq", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 203 +fn c191_l203_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c191_l203_action_invoke"); + let result = instance.call("eq", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 204 +fn c192_l204_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c192_l204_action_invoke"); + let result = instance.call("eq", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 205 +fn c193_l205_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c193_l205_action_invoke"); + let result = instance.call("eq", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 206 +fn c194_l206_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c194_l206_action_invoke"); + let result = instance.call("eq", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 207 +fn c195_l207_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c195_l207_action_invoke"); + let result = instance.call("eq", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 208 +fn c196_l208_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c196_l208_action_invoke"); + let result = instance.call("eq", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 209 +fn c197_l209_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c197_l209_action_invoke"); + let result = instance.call("eq", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 210 +fn c198_l210_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c198_l210_action_invoke"); + let result = instance.call("eq", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 211 +fn c199_l211_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c199_l211_action_invoke"); + let result = instance.call("eq", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 212 +fn c200_l212_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c200_l212_action_invoke"); + let result = instance.call("eq", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 213 +fn c201_l213_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c201_l213_action_invoke"); + let result = instance.call("eq", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 214 +fn c202_l214_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c202_l214_action_invoke"); + let result = instance.call("eq", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 215 +fn c203_l215_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c203_l215_action_invoke"); + let result = instance.call("eq", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 216 +fn c204_l216_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c204_l216_action_invoke"); + let result = instance.call("eq", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 217 +fn c205_l217_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c205_l217_action_invoke"); + let result = instance.call("eq", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 218 +fn c206_l218_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c206_l218_action_invoke"); + let result = instance.call("eq", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 219 +fn c207_l219_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c207_l219_action_invoke"); + let result = instance.call("eq", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 220 +fn c208_l220_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c208_l220_action_invoke"); + let result = instance.call("eq", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 221 +fn c209_l221_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c209_l221_action_invoke"); + let result = instance.call("eq", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 222 +fn c210_l222_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c210_l222_action_invoke"); + let result = instance.call("eq", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 223 +fn c211_l223_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c211_l223_action_invoke"); + let result = instance.call("eq", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 224 +fn c212_l224_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c212_l224_action_invoke"); + let result = instance.call("eq", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 225 +fn c213_l225_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c213_l225_action_invoke"); + let result = instance.call("eq", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 226 +fn c214_l226_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c214_l226_action_invoke"); + let result = instance.call("eq", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 227 +fn c215_l227_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c215_l227_action_invoke"); + let result = instance.call("eq", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 228 +fn c216_l228_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c216_l228_action_invoke"); + let result = instance.call("eq", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 229 +fn c217_l229_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c217_l229_action_invoke"); + let result = instance.call("eq", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 230 +fn c218_l230_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c218_l230_action_invoke"); + let result = instance.call("eq", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 231 +fn c219_l231_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c219_l231_action_invoke"); + let result = instance.call("eq", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 232 +fn c220_l232_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c220_l232_action_invoke"); + let result = instance.call("eq", &[Value::F32((6.2831855f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 233 +fn c221_l233_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c221_l233_action_invoke"); + let result = instance.call("eq", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 234 +fn c222_l234_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c222_l234_action_invoke"); + let result = instance.call("eq", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 235 +fn c223_l235_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c223_l235_action_invoke"); + let result = instance.call("eq", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 236 +fn c224_l236_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c224_l236_action_invoke"); + let result = instance.call("eq", &[Value::F32((6.2831855f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 237 +fn c225_l237_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c225_l237_action_invoke"); + let result = instance.call("eq", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 238 +fn c226_l238_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c226_l238_action_invoke"); + let result = instance.call("eq", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 239 +fn c227_l239_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c227_l239_action_invoke"); + let result = instance.call("eq", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 240 +fn c228_l240_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c228_l240_action_invoke"); + let result = instance.call("eq", &[Value::F32((6.2831855f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 241 +fn c229_l241_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c229_l241_action_invoke"); + let result = instance.call("eq", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 242 +fn c230_l242_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c230_l242_action_invoke"); + let result = instance.call("eq", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 243 +fn c231_l243_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c231_l243_action_invoke"); + let result = instance.call("eq", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 244 +fn c232_l244_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c232_l244_action_invoke"); + let result = instance.call("eq", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 245 +fn c233_l245_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c233_l245_action_invoke"); + let result = instance.call("eq", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 246 +fn c234_l246_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c234_l246_action_invoke"); + let result = instance.call("eq", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 247 +fn c235_l247_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c235_l247_action_invoke"); + let result = instance.call("eq", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 248 +fn c236_l248_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c236_l248_action_invoke"); + let result = instance.call("eq", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 249 +fn c237_l249_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c237_l249_action_invoke"); + let result = instance.call("eq", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 250 +fn c238_l250_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c238_l250_action_invoke"); + let result = instance.call("eq", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 251 +fn c239_l251_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c239_l251_action_invoke"); + let result = instance.call("eq", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 252 +fn c240_l252_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c240_l252_action_invoke"); + let result = instance.call("eq", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 253 +fn c241_l253_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c241_l253_action_invoke"); + let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 254 +fn c242_l254_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c242_l254_action_invoke"); + let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 255 +fn c243_l255_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c243_l255_action_invoke"); + let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 256 +fn c244_l256_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c244_l256_action_invoke"); + let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 257 +fn c245_l257_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c245_l257_action_invoke"); + let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 258 +fn c246_l258_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c246_l258_action_invoke"); + let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 259 +fn c247_l259_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c247_l259_action_invoke"); + let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 260 +fn c248_l260_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c248_l260_action_invoke"); + let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 261 +fn c249_l261_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c249_l261_action_invoke"); + let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 262 +fn c250_l262_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c250_l262_action_invoke"); + let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 263 +fn c251_l263_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c251_l263_action_invoke"); + let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 264 +fn c252_l264_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c252_l264_action_invoke"); + let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 265 +fn c253_l265_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c253_l265_action_invoke"); + let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 266 +fn c254_l266_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c254_l266_action_invoke"); + let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 267 +fn c255_l267_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c255_l267_action_invoke"); + let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 268 +fn c256_l268_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c256_l268_action_invoke"); + let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 269 +fn c257_l269_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c257_l269_action_invoke"); + let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 270 +fn c258_l270_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c258_l270_action_invoke"); + let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 271 +fn c259_l271_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c259_l271_action_invoke"); + let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 272 +fn c260_l272_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c260_l272_action_invoke"); + let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 273 +fn c261_l273_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c261_l273_action_invoke"); + let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 274 +fn c262_l274_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c262_l274_action_invoke"); + let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 275 +fn c263_l275_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c263_l275_action_invoke"); + let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 276 +fn c264_l276_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c264_l276_action_invoke"); + let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 277 +fn c265_l277_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c265_l277_action_invoke"); + let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 278 +fn c266_l278_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c266_l278_action_invoke"); + let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 279 +fn c267_l279_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c267_l279_action_invoke"); + let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 280 +fn c268_l280_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c268_l280_action_invoke"); + let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 281 +fn c269_l281_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c269_l281_action_invoke"); + let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 282 +fn c270_l282_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c270_l282_action_invoke"); + let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 283 +fn c271_l283_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c271_l283_action_invoke"); + let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 284 +fn c272_l284_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c272_l284_action_invoke"); + let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 285 +fn c273_l285_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c273_l285_action_invoke"); + let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 286 +fn c274_l286_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c274_l286_action_invoke"); + let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 287 +fn c275_l287_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c275_l287_action_invoke"); + let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 288 +fn c276_l288_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c276_l288_action_invoke"); + let result = instance.call("eq", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 289 +fn c277_l289_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c277_l289_action_invoke"); + let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 290 +fn c278_l290_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c278_l290_action_invoke"); + let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 291 +fn c279_l291_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c279_l291_action_invoke"); + let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 292 +fn c280_l292_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c280_l292_action_invoke"); + let result = instance.call("eq", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 293 +fn c281_l293_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c281_l293_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 294 +fn c282_l294_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c282_l294_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 295 +fn c283_l295_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c283_l295_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 296 +fn c284_l296_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c284_l296_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 297 +fn c285_l297_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c285_l297_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 298 +fn c286_l298_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c286_l298_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 299 +fn c287_l299_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c287_l299_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 300 +fn c288_l300_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c288_l300_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 301 +fn c289_l301_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c289_l301_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 302 +fn c290_l302_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c290_l302_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 303 +fn c291_l303_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c291_l303_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 304 +fn c292_l304_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c292_l304_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 305 +fn c293_l305_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c293_l305_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 306 +fn c294_l306_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c294_l306_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 307 +fn c295_l307_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c295_l307_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 308 +fn c296_l308_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c296_l308_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 309 +fn c297_l309_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c297_l309_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 310 +fn c298_l310_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c298_l310_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 311 +fn c299_l311_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c299_l311_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 312 +fn c300_l312_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c300_l312_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 313 +fn c301_l313_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c301_l313_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 314 +fn c302_l314_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c302_l314_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 315 +fn c303_l315_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c303_l315_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 316 +fn c304_l316_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c304_l316_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 317 +fn c305_l317_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c305_l317_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 318 +fn c306_l318_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c306_l318_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 319 +fn c307_l319_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c307_l319_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 320 +fn c308_l320_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c308_l320_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 321 +fn c309_l321_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c309_l321_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 322 +fn c310_l322_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c310_l322_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 323 +fn c311_l323_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c311_l323_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 324 +fn c312_l324_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c312_l324_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 325 +fn c313_l325_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c313_l325_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 326 +fn c314_l326_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c314_l326_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 327 +fn c315_l327_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c315_l327_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 328 +fn c316_l328_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c316_l328_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 329 +fn c317_l329_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c317_l329_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 330 +fn c318_l330_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c318_l330_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 331 +fn c319_l331_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c319_l331_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 332 +fn c320_l332_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c320_l332_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 333 +fn c321_l333_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c321_l333_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 334 +fn c322_l334_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c322_l334_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 335 +fn c323_l335_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c323_l335_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 336 +fn c324_l336_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c324_l336_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 337 +fn c325_l337_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c325_l337_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 338 +fn c326_l338_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c326_l338_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 339 +fn c327_l339_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c327_l339_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 340 +fn c328_l340_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c328_l340_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 341 +fn c329_l341_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c329_l341_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 342 +fn c330_l342_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c330_l342_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 343 +fn c331_l343_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c331_l343_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 344 +fn c332_l344_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c332_l344_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 345 +fn c333_l345_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c333_l345_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 346 +fn c334_l346_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c334_l346_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 347 +fn c335_l347_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c335_l347_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 348 +fn c336_l348_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c336_l348_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 349 +fn c337_l349_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c337_l349_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 350 +fn c338_l350_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c338_l350_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 351 +fn c339_l351_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c339_l351_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 352 +fn c340_l352_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c340_l352_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 353 +fn c341_l353_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c341_l353_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 354 +fn c342_l354_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c342_l354_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 355 +fn c343_l355_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c343_l355_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 356 +fn c344_l356_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c344_l356_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 357 +fn c345_l357_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c345_l357_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 358 +fn c346_l358_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c346_l358_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 359 +fn c347_l359_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c347_l359_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 360 +fn c348_l360_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c348_l360_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 361 +fn c349_l361_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c349_l361_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 362 +fn c350_l362_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c350_l362_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 363 +fn c351_l363_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c351_l363_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 364 +fn c352_l364_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c352_l364_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 365 +fn c353_l365_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c353_l365_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 366 +fn c354_l366_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c354_l366_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 367 +fn c355_l367_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c355_l367_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 368 +fn c356_l368_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c356_l368_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 369 +fn c357_l369_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c357_l369_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 370 +fn c358_l370_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c358_l370_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 371 +fn c359_l371_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c359_l371_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 372 +fn c360_l372_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c360_l372_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 373 +fn c361_l373_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c361_l373_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 374 +fn c362_l374_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c362_l374_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 375 +fn c363_l375_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c363_l375_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 376 +fn c364_l376_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c364_l376_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 377 +fn c365_l377_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c365_l377_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 378 +fn c366_l378_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c366_l378_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 379 +fn c367_l379_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c367_l379_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 380 +fn c368_l380_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c368_l380_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 381 +fn c369_l381_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c369_l381_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 382 +fn c370_l382_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c370_l382_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 383 +fn c371_l383_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c371_l383_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 384 +fn c372_l384_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c372_l384_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 385 +fn c373_l385_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c373_l385_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 386 +fn c374_l386_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c374_l386_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 387 +fn c375_l387_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c375_l387_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 388 +fn c376_l388_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c376_l388_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 389 +fn c377_l389_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c377_l389_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 390 +fn c378_l390_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c378_l390_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 391 +fn c379_l391_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c379_l391_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 392 +fn c380_l392_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c380_l392_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 393 +fn c381_l393_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c381_l393_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 394 +fn c382_l394_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c382_l394_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 395 +fn c383_l395_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c383_l395_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 396 +fn c384_l396_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c384_l396_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 397 +fn c385_l397_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c385_l397_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 398 +fn c386_l398_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c386_l398_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 399 +fn c387_l399_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c387_l399_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 400 +fn c388_l400_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c388_l400_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 401 +fn c389_l401_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c389_l401_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 402 +fn c390_l402_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c390_l402_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 403 +fn c391_l403_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c391_l403_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 404 +fn c392_l404_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c392_l404_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 405 +fn c393_l405_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c393_l405_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 406 +fn c394_l406_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c394_l406_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 407 +fn c395_l407_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c395_l407_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 408 +fn c396_l408_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c396_l408_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 409 +fn c397_l409_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c397_l409_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 410 +fn c398_l410_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c398_l410_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 411 +fn c399_l411_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c399_l411_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 412 +fn c400_l412_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c400_l412_action_invoke"); + let result = instance.call("eq", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 413 +fn c401_l413_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c401_l413_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 414 +fn c402_l414_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c402_l414_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 415 +fn c403_l415_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c403_l415_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 416 +fn c404_l416_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c404_l416_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 417 +fn c405_l417_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c405_l417_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 418 +fn c406_l418_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c406_l418_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 419 +fn c407_l419_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c407_l419_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 420 +fn c408_l420_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c408_l420_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 421 +fn c409_l421_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c409_l421_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 422 +fn c410_l422_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c410_l422_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 423 +fn c411_l423_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c411_l423_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 424 +fn c412_l424_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c412_l424_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 425 +fn c413_l425_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c413_l425_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 426 +fn c414_l426_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c414_l426_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 427 +fn c415_l427_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c415_l427_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 428 +fn c416_l428_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c416_l428_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 429 +fn c417_l429_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c417_l429_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 430 +fn c418_l430_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c418_l430_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 431 +fn c419_l431_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c419_l431_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 432 +fn c420_l432_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c420_l432_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 433 +fn c421_l433_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c421_l433_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 434 +fn c422_l434_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c422_l434_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 435 +fn c423_l435_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c423_l435_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 436 +fn c424_l436_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c424_l436_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 437 +fn c425_l437_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c425_l437_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 438 +fn c426_l438_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c426_l438_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 439 +fn c427_l439_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c427_l439_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 440 +fn c428_l440_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c428_l440_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 441 +fn c429_l441_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c429_l441_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 442 +fn c430_l442_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c430_l442_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 443 +fn c431_l443_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c431_l443_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 444 +fn c432_l444_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c432_l444_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 445 +fn c433_l445_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c433_l445_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 446 +fn c434_l446_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c434_l446_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 447 +fn c435_l447_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c435_l447_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 448 +fn c436_l448_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c436_l448_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 449 +fn c437_l449_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c437_l449_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 450 +fn c438_l450_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c438_l450_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 451 +fn c439_l451_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c439_l451_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 452 +fn c440_l452_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c440_l452_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 453 +fn c441_l453_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c441_l453_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 454 +fn c442_l454_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c442_l454_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 455 +fn c443_l455_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c443_l455_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 456 +fn c444_l456_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c444_l456_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 457 +fn c445_l457_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c445_l457_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 458 +fn c446_l458_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c446_l458_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 459 +fn c447_l459_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c447_l459_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 460 +fn c448_l460_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c448_l460_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 461 +fn c449_l461_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c449_l461_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 462 +fn c450_l462_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c450_l462_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 463 +fn c451_l463_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c451_l463_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 464 +fn c452_l464_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c452_l464_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 465 +fn c453_l465_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c453_l465_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 466 +fn c454_l466_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c454_l466_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 467 +fn c455_l467_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c455_l467_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 468 +fn c456_l468_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c456_l468_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 469 +fn c457_l469_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c457_l469_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 470 +fn c458_l470_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c458_l470_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 471 +fn c459_l471_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c459_l471_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 472 +fn c460_l472_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c460_l472_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 473 +fn c461_l473_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c461_l473_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 474 +fn c462_l474_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c462_l474_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 475 +fn c463_l475_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c463_l475_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 476 +fn c464_l476_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c464_l476_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 477 +fn c465_l477_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c465_l477_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 478 +fn c466_l478_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c466_l478_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 479 +fn c467_l479_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c467_l479_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 480 +fn c468_l480_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c468_l480_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 481 +fn c469_l481_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c469_l481_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 482 +fn c470_l482_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c470_l482_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 483 +fn c471_l483_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c471_l483_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 484 +fn c472_l484_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c472_l484_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 485 +fn c473_l485_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c473_l485_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 486 +fn c474_l486_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c474_l486_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 487 +fn c475_l487_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c475_l487_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 488 +fn c476_l488_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c476_l488_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 489 +fn c477_l489_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c477_l489_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 490 +fn c478_l490_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c478_l490_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 491 +fn c479_l491_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c479_l491_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 492 +fn c480_l492_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c480_l492_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 493 +fn c481_l493_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c481_l493_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 494 +fn c482_l494_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c482_l494_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 495 +fn c483_l495_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c483_l495_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 496 +fn c484_l496_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c484_l496_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 497 +fn c485_l497_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c485_l497_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 498 +fn c486_l498_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c486_l498_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 499 +fn c487_l499_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c487_l499_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 500 +fn c488_l500_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c488_l500_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 501 +fn c489_l501_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c489_l501_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 502 +fn c490_l502_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c490_l502_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 503 +fn c491_l503_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c491_l503_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 504 +fn c492_l504_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c492_l504_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 505 +fn c493_l505_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c493_l505_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 506 +fn c494_l506_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c494_l506_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 507 +fn c495_l507_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c495_l507_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 508 +fn c496_l508_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c496_l508_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 509 +fn c497_l509_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c497_l509_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 510 +fn c498_l510_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c498_l510_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 511 +fn c499_l511_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c499_l511_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 512 +fn c500_l512_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c500_l512_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 513 +fn c501_l513_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c501_l513_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 514 +fn c502_l514_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c502_l514_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 515 +fn c503_l515_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c503_l515_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 516 +fn c504_l516_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c504_l516_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 517 +fn c505_l517_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c505_l517_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 518 +fn c506_l518_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c506_l518_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 519 +fn c507_l519_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c507_l519_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 520 +fn c508_l520_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c508_l520_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 521 +fn c509_l521_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c509_l521_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 522 +fn c510_l522_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c510_l522_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 523 +fn c511_l523_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c511_l523_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 524 +fn c512_l524_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c512_l524_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 525 +fn c513_l525_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c513_l525_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 526 +fn c514_l526_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c514_l526_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 527 +fn c515_l527_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c515_l527_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 528 +fn c516_l528_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c516_l528_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 529 +fn c517_l529_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c517_l529_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 530 +fn c518_l530_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c518_l530_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 531 +fn c519_l531_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c519_l531_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 532 +fn c520_l532_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c520_l532_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 533 +fn c521_l533_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c521_l533_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 534 +fn c522_l534_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c522_l534_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 535 +fn c523_l535_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c523_l535_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 536 +fn c524_l536_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c524_l536_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.5f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 537 +fn c525_l537_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c525_l537_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 538 +fn c526_l538_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c526_l538_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 539 +fn c527_l539_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c527_l539_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 540 +fn c528_l540_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c528_l540_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 541 +fn c529_l541_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c529_l541_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 542 +fn c530_l542_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c530_l542_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 543 +fn c531_l543_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c531_l543_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 544 +fn c532_l544_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c532_l544_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 545 +fn c533_l545_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c533_l545_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 546 +fn c534_l546_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c534_l546_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 547 +fn c535_l547_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c535_l547_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 548 +fn c536_l548_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c536_l548_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.5f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 549 +fn c537_l549_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c537_l549_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.5f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 550 +fn c538_l550_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c538_l550_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.5f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 551 +fn c539_l551_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c539_l551_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.5f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 552 +fn c540_l552_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c540_l552_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.5f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 553 +fn c541_l553_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c541_l553_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.5f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 554 +fn c542_l554_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c542_l554_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.5f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 555 +fn c543_l555_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c543_l555_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.5f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 556 +fn c544_l556_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c544_l556_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.5f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 557 +fn c545_l557_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c545_l557_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.5f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 558 +fn c546_l558_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c546_l558_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.5f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 559 +fn c547_l559_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c547_l559_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.5f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 560 +fn c548_l560_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c548_l560_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.5f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 561 +fn c549_l561_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c549_l561_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 562 +fn c550_l562_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c550_l562_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 563 +fn c551_l563_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c551_l563_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 564 +fn c552_l564_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c552_l564_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 565 +fn c553_l565_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c553_l565_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 566 +fn c554_l566_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c554_l566_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 567 +fn c555_l567_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c555_l567_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 568 +fn c556_l568_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c556_l568_action_invoke"); + let result = instance.call("ne", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 569 +fn c557_l569_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c557_l569_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 570 +fn c558_l570_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c558_l570_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 571 +fn c559_l571_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c559_l571_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 572 +fn c560_l572_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c560_l572_action_invoke"); + let result = instance.call("ne", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 573 +fn c561_l573_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c561_l573_action_invoke"); + let result = instance.call("ne", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 574 +fn c562_l574_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c562_l574_action_invoke"); + let result = instance.call("ne", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 575 +fn c563_l575_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c563_l575_action_invoke"); + let result = instance.call("ne", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 576 +fn c564_l576_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c564_l576_action_invoke"); + let result = instance.call("ne", &[Value::F32((1.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 577 +fn c565_l577_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c565_l577_action_invoke"); + let result = instance.call("ne", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 578 +fn c566_l578_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c566_l578_action_invoke"); + let result = instance.call("ne", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 579 +fn c567_l579_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c567_l579_action_invoke"); + let result = instance.call("ne", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 580 +fn c568_l580_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c568_l580_action_invoke"); + let result = instance.call("ne", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 581 +fn c569_l581_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c569_l581_action_invoke"); + let result = instance.call("ne", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 582 +fn c570_l582_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c570_l582_action_invoke"); + let result = instance.call("ne", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 583 +fn c571_l583_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c571_l583_action_invoke"); + let result = instance.call("ne", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 584 +fn c572_l584_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c572_l584_action_invoke"); + let result = instance.call("ne", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 585 +fn c573_l585_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c573_l585_action_invoke"); + let result = instance.call("ne", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 586 +fn c574_l586_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c574_l586_action_invoke"); + let result = instance.call("ne", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 587 +fn c575_l587_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c575_l587_action_invoke"); + let result = instance.call("ne", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 588 +fn c576_l588_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c576_l588_action_invoke"); + let result = instance.call("ne", &[Value::F32((1.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 589 +fn c577_l589_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c577_l589_action_invoke"); + let result = instance.call("ne", &[Value::F32((-1.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 590 +fn c578_l590_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c578_l590_action_invoke"); + let result = instance.call("ne", &[Value::F32((-1.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 591 +fn c579_l591_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c579_l591_action_invoke"); + let result = instance.call("ne", &[Value::F32((1.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 592 +fn c580_l592_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c580_l592_action_invoke"); + let result = instance.call("ne", &[Value::F32((1.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 593 +fn c581_l593_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c581_l593_action_invoke"); + let result = instance.call("ne", &[Value::F32((-1.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 594 +fn c582_l594_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c582_l594_action_invoke"); + let result = instance.call("ne", &[Value::F32((-1.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 595 +fn c583_l595_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c583_l595_action_invoke"); + let result = instance.call("ne", &[Value::F32((1.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 596 +fn c584_l596_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c584_l596_action_invoke"); + let result = instance.call("ne", &[Value::F32((1.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 597 +fn c585_l597_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c585_l597_action_invoke"); + let result = instance.call("ne", &[Value::F32((-1.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 598 +fn c586_l598_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c586_l598_action_invoke"); + let result = instance.call("ne", &[Value::F32((-1.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 599 +fn c587_l599_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c587_l599_action_invoke"); + let result = instance.call("ne", &[Value::F32((1.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 600 +fn c588_l600_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c588_l600_action_invoke"); + let result = instance.call("ne", &[Value::F32((1.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 601 +fn c589_l601_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c589_l601_action_invoke"); + let result = instance.call("ne", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 602 +fn c590_l602_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c590_l602_action_invoke"); + let result = instance.call("ne", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 603 +fn c591_l603_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c591_l603_action_invoke"); + let result = instance.call("ne", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 604 +fn c592_l604_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c592_l604_action_invoke"); + let result = instance.call("ne", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 605 +fn c593_l605_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c593_l605_action_invoke"); + let result = instance.call("ne", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 606 +fn c594_l606_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c594_l606_action_invoke"); + let result = instance.call("ne", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 607 +fn c595_l607_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c595_l607_action_invoke"); + let result = instance.call("ne", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 608 +fn c596_l608_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c596_l608_action_invoke"); + let result = instance.call("ne", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 609 +fn c597_l609_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c597_l609_action_invoke"); + let result = instance.call("ne", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 610 +fn c598_l610_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c598_l610_action_invoke"); + let result = instance.call("ne", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 611 +fn c599_l611_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c599_l611_action_invoke"); + let result = instance.call("ne", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 612 +fn c600_l612_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c600_l612_action_invoke"); + let result = instance.call("ne", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 613 +fn c601_l613_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c601_l613_action_invoke"); + let result = instance.call("ne", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 614 +fn c602_l614_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c602_l614_action_invoke"); + let result = instance.call("ne", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 615 +fn c603_l615_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c603_l615_action_invoke"); + let result = instance.call("ne", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 616 +fn c604_l616_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c604_l616_action_invoke"); + let result = instance.call("ne", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 617 +fn c605_l617_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c605_l617_action_invoke"); + let result = instance.call("ne", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 618 +fn c606_l618_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c606_l618_action_invoke"); + let result = instance.call("ne", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 619 +fn c607_l619_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c607_l619_action_invoke"); + let result = instance.call("ne", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 620 +fn c608_l620_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c608_l620_action_invoke"); + let result = instance.call("ne", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 621 +fn c609_l621_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c609_l621_action_invoke"); + let result = instance.call("ne", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 622 +fn c610_l622_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c610_l622_action_invoke"); + let result = instance.call("ne", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 623 +fn c611_l623_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c611_l623_action_invoke"); + let result = instance.call("ne", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 624 +fn c612_l624_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c612_l624_action_invoke"); + let result = instance.call("ne", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 625 +fn c613_l625_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c613_l625_action_invoke"); + let result = instance.call("ne", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 626 +fn c614_l626_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c614_l626_action_invoke"); + let result = instance.call("ne", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 627 +fn c615_l627_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c615_l627_action_invoke"); + let result = instance.call("ne", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 628 +fn c616_l628_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c616_l628_action_invoke"); + let result = instance.call("ne", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 629 +fn c617_l629_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c617_l629_action_invoke"); + let result = instance.call("ne", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 630 +fn c618_l630_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c618_l630_action_invoke"); + let result = instance.call("ne", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 631 +fn c619_l631_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c619_l631_action_invoke"); + let result = instance.call("ne", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 632 +fn c620_l632_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c620_l632_action_invoke"); + let result = instance.call("ne", &[Value::F32((6.2831855f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 633 +fn c621_l633_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c621_l633_action_invoke"); + let result = instance.call("ne", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 634 +fn c622_l634_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c622_l634_action_invoke"); + let result = instance.call("ne", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 635 +fn c623_l635_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c623_l635_action_invoke"); + let result = instance.call("ne", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 636 +fn c624_l636_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c624_l636_action_invoke"); + let result = instance.call("ne", &[Value::F32((6.2831855f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 637 +fn c625_l637_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c625_l637_action_invoke"); + let result = instance.call("ne", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 638 +fn c626_l638_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c626_l638_action_invoke"); + let result = instance.call("ne", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 639 +fn c627_l639_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c627_l639_action_invoke"); + let result = instance.call("ne", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 640 +fn c628_l640_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c628_l640_action_invoke"); + let result = instance.call("ne", &[Value::F32((6.2831855f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 641 +fn c629_l641_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c629_l641_action_invoke"); + let result = instance.call("ne", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 642 +fn c630_l642_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c630_l642_action_invoke"); + let result = instance.call("ne", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 643 +fn c631_l643_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c631_l643_action_invoke"); + let result = instance.call("ne", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 644 +fn c632_l644_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c632_l644_action_invoke"); + let result = instance.call("ne", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 645 +fn c633_l645_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c633_l645_action_invoke"); + let result = instance.call("ne", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 646 +fn c634_l646_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c634_l646_action_invoke"); + let result = instance.call("ne", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 647 +fn c635_l647_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c635_l647_action_invoke"); + let result = instance.call("ne", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 648 +fn c636_l648_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c636_l648_action_invoke"); + let result = instance.call("ne", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 649 +fn c637_l649_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c637_l649_action_invoke"); + let result = instance.call("ne", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 650 +fn c638_l650_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c638_l650_action_invoke"); + let result = instance.call("ne", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 651 +fn c639_l651_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c639_l651_action_invoke"); + let result = instance.call("ne", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 652 +fn c640_l652_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c640_l652_action_invoke"); + let result = instance.call("ne", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 653 +fn c641_l653_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c641_l653_action_invoke"); + let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 654 +fn c642_l654_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c642_l654_action_invoke"); + let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 655 +fn c643_l655_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c643_l655_action_invoke"); + let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 656 +fn c644_l656_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c644_l656_action_invoke"); + let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 657 +fn c645_l657_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c645_l657_action_invoke"); + let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 658 +fn c646_l658_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c646_l658_action_invoke"); + let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 659 +fn c647_l659_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c647_l659_action_invoke"); + let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 660 +fn c648_l660_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c648_l660_action_invoke"); + let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 661 +fn c649_l661_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c649_l661_action_invoke"); + let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 662 +fn c650_l662_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c650_l662_action_invoke"); + let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 663 +fn c651_l663_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c651_l663_action_invoke"); + let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 664 +fn c652_l664_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c652_l664_action_invoke"); + let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 665 +fn c653_l665_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c653_l665_action_invoke"); + let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 666 +fn c654_l666_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c654_l666_action_invoke"); + let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 667 +fn c655_l667_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c655_l667_action_invoke"); + let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 668 +fn c656_l668_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c656_l668_action_invoke"); + let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 669 +fn c657_l669_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c657_l669_action_invoke"); + let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 670 +fn c658_l670_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c658_l670_action_invoke"); + let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 671 +fn c659_l671_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c659_l671_action_invoke"); + let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 672 +fn c660_l672_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c660_l672_action_invoke"); + let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 673 +fn c661_l673_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c661_l673_action_invoke"); + let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 674 +fn c662_l674_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c662_l674_action_invoke"); + let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 675 +fn c663_l675_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c663_l675_action_invoke"); + let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 676 +fn c664_l676_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c664_l676_action_invoke"); + let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 677 +fn c665_l677_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c665_l677_action_invoke"); + let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 678 +fn c666_l678_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c666_l678_action_invoke"); + let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 679 +fn c667_l679_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c667_l679_action_invoke"); + let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 680 +fn c668_l680_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c668_l680_action_invoke"); + let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 681 +fn c669_l681_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c669_l681_action_invoke"); + let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 682 +fn c670_l682_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c670_l682_action_invoke"); + let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 683 +fn c671_l683_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c671_l683_action_invoke"); + let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 684 +fn c672_l684_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c672_l684_action_invoke"); + let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 685 +fn c673_l685_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c673_l685_action_invoke"); + let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 686 +fn c674_l686_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c674_l686_action_invoke"); + let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 687 +fn c675_l687_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c675_l687_action_invoke"); + let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 688 +fn c676_l688_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c676_l688_action_invoke"); + let result = instance.call("ne", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 689 +fn c677_l689_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c677_l689_action_invoke"); + let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 690 +fn c678_l690_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c678_l690_action_invoke"); + let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 691 +fn c679_l691_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c679_l691_action_invoke"); + let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 692 +fn c680_l692_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c680_l692_action_invoke"); + let result = instance.call("ne", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 693 +fn c681_l693_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c681_l693_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 694 +fn c682_l694_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c682_l694_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 695 +fn c683_l695_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c683_l695_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 696 +fn c684_l696_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c684_l696_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 697 +fn c685_l697_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c685_l697_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 698 +fn c686_l698_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c686_l698_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 699 +fn c687_l699_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c687_l699_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 700 +fn c688_l700_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c688_l700_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 701 +fn c689_l701_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c689_l701_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 702 +fn c690_l702_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c690_l702_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 703 +fn c691_l703_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c691_l703_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 704 +fn c692_l704_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c692_l704_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 705 +fn c693_l705_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c693_l705_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 706 +fn c694_l706_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c694_l706_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 707 +fn c695_l707_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c695_l707_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 708 +fn c696_l708_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c696_l708_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 709 +fn c697_l709_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c697_l709_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 710 +fn c698_l710_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c698_l710_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 711 +fn c699_l711_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c699_l711_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 712 +fn c700_l712_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c700_l712_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 713 +fn c701_l713_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c701_l713_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 714 +fn c702_l714_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c702_l714_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 715 +fn c703_l715_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c703_l715_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 716 +fn c704_l716_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c704_l716_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 717 +fn c705_l717_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c705_l717_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 718 +fn c706_l718_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c706_l718_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 719 +fn c707_l719_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c707_l719_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 720 +fn c708_l720_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c708_l720_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 721 +fn c709_l721_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c709_l721_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 722 +fn c710_l722_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c710_l722_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 723 +fn c711_l723_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c711_l723_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 724 +fn c712_l724_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c712_l724_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 725 +fn c713_l725_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c713_l725_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 726 +fn c714_l726_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c714_l726_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 727 +fn c715_l727_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c715_l727_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 728 +fn c716_l728_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c716_l728_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 729 +fn c717_l729_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c717_l729_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 730 +fn c718_l730_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c718_l730_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 731 +fn c719_l731_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c719_l731_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 732 +fn c720_l732_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c720_l732_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 733 +fn c721_l733_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c721_l733_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 734 +fn c722_l734_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c722_l734_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 735 +fn c723_l735_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c723_l735_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 736 +fn c724_l736_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c724_l736_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 737 +fn c725_l737_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c725_l737_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 738 +fn c726_l738_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c726_l738_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 739 +fn c727_l739_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c727_l739_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 740 +fn c728_l740_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c728_l740_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 741 +fn c729_l741_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c729_l741_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 742 +fn c730_l742_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c730_l742_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 743 +fn c731_l743_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c731_l743_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 744 +fn c732_l744_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c732_l744_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 745 +fn c733_l745_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c733_l745_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 746 +fn c734_l746_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c734_l746_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 747 +fn c735_l747_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c735_l747_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 748 +fn c736_l748_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c736_l748_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 749 +fn c737_l749_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c737_l749_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 750 +fn c738_l750_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c738_l750_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 751 +fn c739_l751_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c739_l751_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 752 +fn c740_l752_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c740_l752_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 753 +fn c741_l753_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c741_l753_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 754 +fn c742_l754_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c742_l754_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 755 +fn c743_l755_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c743_l755_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 756 +fn c744_l756_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c744_l756_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 757 +fn c745_l757_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c745_l757_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 758 +fn c746_l758_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c746_l758_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 759 +fn c747_l759_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c747_l759_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 760 +fn c748_l760_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c748_l760_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 761 +fn c749_l761_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c749_l761_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 762 +fn c750_l762_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c750_l762_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 763 +fn c751_l763_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c751_l763_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 764 +fn c752_l764_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c752_l764_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 765 +fn c753_l765_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c753_l765_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 766 +fn c754_l766_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c754_l766_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 767 +fn c755_l767_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c755_l767_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 768 +fn c756_l768_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c756_l768_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 769 +fn c757_l769_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c757_l769_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 770 +fn c758_l770_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c758_l770_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 771 +fn c759_l771_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c759_l771_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 772 +fn c760_l772_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c760_l772_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 773 +fn c761_l773_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c761_l773_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 774 +fn c762_l774_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c762_l774_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 775 +fn c763_l775_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c763_l775_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 776 +fn c764_l776_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c764_l776_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 777 +fn c765_l777_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c765_l777_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 778 +fn c766_l778_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c766_l778_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 779 +fn c767_l779_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c767_l779_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 780 +fn c768_l780_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c768_l780_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 781 +fn c769_l781_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c769_l781_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 782 +fn c770_l782_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c770_l782_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 783 +fn c771_l783_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c771_l783_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 784 +fn c772_l784_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c772_l784_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 785 +fn c773_l785_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c773_l785_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 786 +fn c774_l786_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c774_l786_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 787 +fn c775_l787_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c775_l787_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 788 +fn c776_l788_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c776_l788_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 789 +fn c777_l789_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c777_l789_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 790 +fn c778_l790_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c778_l790_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 791 +fn c779_l791_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c779_l791_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 792 +fn c780_l792_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c780_l792_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 793 +fn c781_l793_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c781_l793_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 794 +fn c782_l794_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c782_l794_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 795 +fn c783_l795_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c783_l795_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 796 +fn c784_l796_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c784_l796_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 797 +fn c785_l797_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c785_l797_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 798 +fn c786_l798_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c786_l798_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 799 +fn c787_l799_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c787_l799_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 800 +fn c788_l800_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c788_l800_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 801 +fn c789_l801_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c789_l801_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 802 +fn c790_l802_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c790_l802_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 803 +fn c791_l803_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c791_l803_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 804 +fn c792_l804_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c792_l804_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 805 +fn c793_l805_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c793_l805_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 806 +fn c794_l806_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c794_l806_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 807 +fn c795_l807_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c795_l807_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 808 +fn c796_l808_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c796_l808_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 809 +fn c797_l809_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c797_l809_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 810 +fn c798_l810_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c798_l810_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 811 +fn c799_l811_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c799_l811_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 812 +fn c800_l812_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c800_l812_action_invoke"); + let result = instance.call("ne", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 813 +fn c801_l813_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c801_l813_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 814 +fn c802_l814_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c802_l814_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 815 +fn c803_l815_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c803_l815_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 816 +fn c804_l816_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c804_l816_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 817 +fn c805_l817_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c805_l817_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 818 +fn c806_l818_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c806_l818_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 819 +fn c807_l819_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c807_l819_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 820 +fn c808_l820_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c808_l820_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 821 +fn c809_l821_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c809_l821_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 822 +fn c810_l822_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c810_l822_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 823 +fn c811_l823_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c811_l823_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 824 +fn c812_l824_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c812_l824_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 825 +fn c813_l825_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c813_l825_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 826 +fn c814_l826_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c814_l826_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 827 +fn c815_l827_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c815_l827_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 828 +fn c816_l828_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c816_l828_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 829 +fn c817_l829_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c817_l829_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 830 +fn c818_l830_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c818_l830_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 831 +fn c819_l831_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c819_l831_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 832 +fn c820_l832_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c820_l832_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 833 +fn c821_l833_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c821_l833_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 834 +fn c822_l834_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c822_l834_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 835 +fn c823_l835_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c823_l835_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 836 +fn c824_l836_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c824_l836_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 837 +fn c825_l837_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c825_l837_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 838 +fn c826_l838_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c826_l838_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 839 +fn c827_l839_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c827_l839_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 840 +fn c828_l840_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c828_l840_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 841 +fn c829_l841_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c829_l841_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 842 +fn c830_l842_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c830_l842_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 843 +fn c831_l843_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c831_l843_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 844 +fn c832_l844_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c832_l844_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 845 +fn c833_l845_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c833_l845_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 846 +fn c834_l846_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c834_l846_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 847 +fn c835_l847_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c835_l847_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 848 +fn c836_l848_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c836_l848_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 849 +fn c837_l849_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c837_l849_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 850 +fn c838_l850_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c838_l850_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 851 +fn c839_l851_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c839_l851_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 852 +fn c840_l852_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c840_l852_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 853 +fn c841_l853_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c841_l853_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 854 +fn c842_l854_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c842_l854_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 855 +fn c843_l855_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c843_l855_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 856 +fn c844_l856_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c844_l856_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 857 +fn c845_l857_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c845_l857_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 858 +fn c846_l858_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c846_l858_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 859 +fn c847_l859_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c847_l859_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 860 +fn c848_l860_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c848_l860_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 861 +fn c849_l861_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c849_l861_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 862 +fn c850_l862_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c850_l862_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 863 +fn c851_l863_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c851_l863_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 864 +fn c852_l864_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c852_l864_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 865 +fn c853_l865_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c853_l865_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 866 +fn c854_l866_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c854_l866_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 867 +fn c855_l867_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c855_l867_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 868 +fn c856_l868_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c856_l868_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 869 +fn c857_l869_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c857_l869_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 870 +fn c858_l870_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c858_l870_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 871 +fn c859_l871_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c859_l871_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 872 +fn c860_l872_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c860_l872_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 873 +fn c861_l873_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c861_l873_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 874 +fn c862_l874_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c862_l874_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 875 +fn c863_l875_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c863_l875_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 876 +fn c864_l876_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c864_l876_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 877 +fn c865_l877_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c865_l877_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 878 +fn c866_l878_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c866_l878_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 879 +fn c867_l879_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c867_l879_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 880 +fn c868_l880_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c868_l880_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 881 +fn c869_l881_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c869_l881_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 882 +fn c870_l882_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c870_l882_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 883 +fn c871_l883_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c871_l883_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 884 +fn c872_l884_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c872_l884_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 885 +fn c873_l885_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c873_l885_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 886 +fn c874_l886_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c874_l886_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 887 +fn c875_l887_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c875_l887_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 888 +fn c876_l888_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c876_l888_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 889 +fn c877_l889_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c877_l889_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 890 +fn c878_l890_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c878_l890_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 891 +fn c879_l891_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c879_l891_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 892 +fn c880_l892_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c880_l892_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 893 +fn c881_l893_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c881_l893_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 894 +fn c882_l894_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c882_l894_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 895 +fn c883_l895_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c883_l895_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 896 +fn c884_l896_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c884_l896_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 897 +fn c885_l897_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c885_l897_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 898 +fn c886_l898_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c886_l898_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 899 +fn c887_l899_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c887_l899_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 900 +fn c888_l900_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c888_l900_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 901 +fn c889_l901_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c889_l901_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 902 +fn c890_l902_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c890_l902_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 903 +fn c891_l903_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c891_l903_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 904 +fn c892_l904_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c892_l904_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 905 +fn c893_l905_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c893_l905_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 906 +fn c894_l906_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c894_l906_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 907 +fn c895_l907_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c895_l907_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 908 +fn c896_l908_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c896_l908_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 909 +fn c897_l909_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c897_l909_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 910 +fn c898_l910_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c898_l910_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 911 +fn c899_l911_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c899_l911_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 912 +fn c900_l912_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c900_l912_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 913 +fn c901_l913_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c901_l913_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 914 +fn c902_l914_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c902_l914_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 915 +fn c903_l915_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c903_l915_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 916 +fn c904_l916_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c904_l916_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 917 +fn c905_l917_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c905_l917_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 918 +fn c906_l918_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c906_l918_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 919 +fn c907_l919_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c907_l919_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 920 +fn c908_l920_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c908_l920_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 921 +fn c909_l921_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c909_l921_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 922 +fn c910_l922_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c910_l922_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 923 +fn c911_l923_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c911_l923_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 924 +fn c912_l924_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c912_l924_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 925 +fn c913_l925_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c913_l925_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 926 +fn c914_l926_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c914_l926_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 927 +fn c915_l927_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c915_l927_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 928 +fn c916_l928_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c916_l928_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 929 +fn c917_l929_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c917_l929_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 930 +fn c918_l930_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c918_l930_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 931 +fn c919_l931_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c919_l931_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 932 +fn c920_l932_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c920_l932_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 933 +fn c921_l933_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c921_l933_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 934 +fn c922_l934_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c922_l934_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 935 +fn c923_l935_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c923_l935_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 936 +fn c924_l936_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c924_l936_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.5f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 937 +fn c925_l937_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c925_l937_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 938 +fn c926_l938_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c926_l938_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 939 +fn c927_l939_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c927_l939_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 940 +fn c928_l940_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c928_l940_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 941 +fn c929_l941_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c929_l941_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 942 +fn c930_l942_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c930_l942_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 943 +fn c931_l943_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c931_l943_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 944 +fn c932_l944_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c932_l944_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 945 +fn c933_l945_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c933_l945_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 946 +fn c934_l946_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c934_l946_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 947 +fn c935_l947_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c935_l947_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 948 +fn c936_l948_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c936_l948_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.5f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 949 +fn c937_l949_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c937_l949_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.5f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 950 +fn c938_l950_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c938_l950_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.5f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 951 +fn c939_l951_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c939_l951_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.5f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 952 +fn c940_l952_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c940_l952_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.5f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 953 +fn c941_l953_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c941_l953_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.5f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 954 +fn c942_l954_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c942_l954_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.5f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 955 +fn c943_l955_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c943_l955_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.5f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 956 +fn c944_l956_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c944_l956_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.5f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 957 +fn c945_l957_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c945_l957_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.5f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 958 +fn c946_l958_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c946_l958_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.5f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 959 +fn c947_l959_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c947_l959_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.5f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 960 +fn c948_l960_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c948_l960_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.5f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 961 +fn c949_l961_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c949_l961_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 962 +fn c950_l962_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c950_l962_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 963 +fn c951_l963_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c951_l963_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 964 +fn c952_l964_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c952_l964_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 965 +fn c953_l965_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c953_l965_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 966 +fn c954_l966_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c954_l966_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 967 +fn c955_l967_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c955_l967_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 968 +fn c956_l968_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c956_l968_action_invoke"); + let result = instance.call("lt", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 969 +fn c957_l969_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c957_l969_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 970 +fn c958_l970_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c958_l970_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 971 +fn c959_l971_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c959_l971_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 972 +fn c960_l972_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c960_l972_action_invoke"); + let result = instance.call("lt", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 973 +fn c961_l973_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c961_l973_action_invoke"); + let result = instance.call("lt", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 974 +fn c962_l974_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c962_l974_action_invoke"); + let result = instance.call("lt", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 975 +fn c963_l975_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c963_l975_action_invoke"); + let result = instance.call("lt", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 976 +fn c964_l976_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c964_l976_action_invoke"); + let result = instance.call("lt", &[Value::F32((1.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 977 +fn c965_l977_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c965_l977_action_invoke"); + let result = instance.call("lt", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 978 +fn c966_l978_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c966_l978_action_invoke"); + let result = instance.call("lt", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 979 +fn c967_l979_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c967_l979_action_invoke"); + let result = instance.call("lt", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 980 +fn c968_l980_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c968_l980_action_invoke"); + let result = instance.call("lt", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 981 +fn c969_l981_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c969_l981_action_invoke"); + let result = instance.call("lt", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 982 +fn c970_l982_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c970_l982_action_invoke"); + let result = instance.call("lt", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 983 +fn c971_l983_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c971_l983_action_invoke"); + let result = instance.call("lt", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 984 +fn c972_l984_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c972_l984_action_invoke"); + let result = instance.call("lt", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 985 +fn c973_l985_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c973_l985_action_invoke"); + let result = instance.call("lt", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 986 +fn c974_l986_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c974_l986_action_invoke"); + let result = instance.call("lt", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 987 +fn c975_l987_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c975_l987_action_invoke"); + let result = instance.call("lt", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 988 +fn c976_l988_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c976_l988_action_invoke"); + let result = instance.call("lt", &[Value::F32((1.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 989 +fn c977_l989_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c977_l989_action_invoke"); + let result = instance.call("lt", &[Value::F32((-1.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 990 +fn c978_l990_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c978_l990_action_invoke"); + let result = instance.call("lt", &[Value::F32((-1.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 991 +fn c979_l991_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c979_l991_action_invoke"); + let result = instance.call("lt", &[Value::F32((1.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 992 +fn c980_l992_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c980_l992_action_invoke"); + let result = instance.call("lt", &[Value::F32((1.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 993 +fn c981_l993_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c981_l993_action_invoke"); + let result = instance.call("lt", &[Value::F32((-1.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 994 +fn c982_l994_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c982_l994_action_invoke"); + let result = instance.call("lt", &[Value::F32((-1.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 995 +fn c983_l995_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c983_l995_action_invoke"); + let result = instance.call("lt", &[Value::F32((1.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 996 +fn c984_l996_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c984_l996_action_invoke"); + let result = instance.call("lt", &[Value::F32((1.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 997 +fn c985_l997_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c985_l997_action_invoke"); + let result = instance.call("lt", &[Value::F32((-1.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 998 +fn c986_l998_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c986_l998_action_invoke"); + let result = instance.call("lt", &[Value::F32((-1.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 999 +fn c987_l999_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c987_l999_action_invoke"); + let result = instance.call("lt", &[Value::F32((1.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1000 +fn c988_l1000_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c988_l1000_action_invoke"); + let result = instance.call("lt", &[Value::F32((1.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1001 +fn c989_l1001_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c989_l1001_action_invoke"); + let result = instance.call("lt", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1002 +fn c990_l1002_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c990_l1002_action_invoke"); + let result = instance.call("lt", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1003 +fn c991_l1003_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c991_l1003_action_invoke"); + let result = instance.call("lt", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1004 +fn c992_l1004_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c992_l1004_action_invoke"); + let result = instance.call("lt", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1005 +fn c993_l1005_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c993_l1005_action_invoke"); + let result = instance.call("lt", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1006 +fn c994_l1006_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c994_l1006_action_invoke"); + let result = instance.call("lt", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1007 +fn c995_l1007_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c995_l1007_action_invoke"); + let result = instance.call("lt", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1008 +fn c996_l1008_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c996_l1008_action_invoke"); + let result = instance.call("lt", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1009 +fn c997_l1009_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c997_l1009_action_invoke"); + let result = instance.call("lt", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1010 +fn c998_l1010_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c998_l1010_action_invoke"); + let result = instance.call("lt", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1011 +fn c999_l1011_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c999_l1011_action_invoke"); + let result = instance.call("lt", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1012 +fn c1000_l1012_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1000_l1012_action_invoke"); + let result = instance.call("lt", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1013 +fn c1001_l1013_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1001_l1013_action_invoke"); + let result = instance.call("lt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1014 +fn c1002_l1014_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1002_l1014_action_invoke"); + let result = instance.call("lt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1015 +fn c1003_l1015_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1003_l1015_action_invoke"); + let result = instance.call("lt", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1016 +fn c1004_l1016_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1004_l1016_action_invoke"); + let result = instance.call("lt", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1017 +fn c1005_l1017_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1005_l1017_action_invoke"); + let result = instance.call("lt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1018 +fn c1006_l1018_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1006_l1018_action_invoke"); + let result = instance.call("lt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1019 +fn c1007_l1019_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1007_l1019_action_invoke"); + let result = instance.call("lt", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1020 +fn c1008_l1020_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1008_l1020_action_invoke"); + let result = instance.call("lt", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1021 +fn c1009_l1021_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1009_l1021_action_invoke"); + let result = instance.call("lt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1022 +fn c1010_l1022_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1010_l1022_action_invoke"); + let result = instance.call("lt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1023 +fn c1011_l1023_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1011_l1023_action_invoke"); + let result = instance.call("lt", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1024 +fn c1012_l1024_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1012_l1024_action_invoke"); + let result = instance.call("lt", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1025 +fn c1013_l1025_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1013_l1025_action_invoke"); + let result = instance.call("lt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1026 +fn c1014_l1026_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1014_l1026_action_invoke"); + let result = instance.call("lt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1027 +fn c1015_l1027_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1015_l1027_action_invoke"); + let result = instance.call("lt", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1028 +fn c1016_l1028_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1016_l1028_action_invoke"); + let result = instance.call("lt", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1029 +fn c1017_l1029_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1017_l1029_action_invoke"); + let result = instance.call("lt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1030 +fn c1018_l1030_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1018_l1030_action_invoke"); + let result = instance.call("lt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1031 +fn c1019_l1031_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1019_l1031_action_invoke"); + let result = instance.call("lt", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1032 +fn c1020_l1032_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1020_l1032_action_invoke"); + let result = instance.call("lt", &[Value::F32((6.2831855f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1033 +fn c1021_l1033_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1021_l1033_action_invoke"); + let result = instance.call("lt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1034 +fn c1022_l1034_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1022_l1034_action_invoke"); + let result = instance.call("lt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1035 +fn c1023_l1035_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1023_l1035_action_invoke"); + let result = instance.call("lt", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1036 +fn c1024_l1036_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1024_l1036_action_invoke"); + let result = instance.call("lt", &[Value::F32((6.2831855f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1037 +fn c1025_l1037_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1025_l1037_action_invoke"); + let result = instance.call("lt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1038 +fn c1026_l1038_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1026_l1038_action_invoke"); + let result = instance.call("lt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1039 +fn c1027_l1039_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1027_l1039_action_invoke"); + let result = instance.call("lt", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1040 +fn c1028_l1040_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1028_l1040_action_invoke"); + let result = instance.call("lt", &[Value::F32((6.2831855f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1041 +fn c1029_l1041_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1029_l1041_action_invoke"); + let result = instance.call("lt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1042 +fn c1030_l1042_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1030_l1042_action_invoke"); + let result = instance.call("lt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1043 +fn c1031_l1043_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1031_l1043_action_invoke"); + let result = instance.call("lt", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1044 +fn c1032_l1044_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1032_l1044_action_invoke"); + let result = instance.call("lt", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1045 +fn c1033_l1045_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1033_l1045_action_invoke"); + let result = instance.call("lt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1046 +fn c1034_l1046_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1034_l1046_action_invoke"); + let result = instance.call("lt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1047 +fn c1035_l1047_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1035_l1047_action_invoke"); + let result = instance.call("lt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1048 +fn c1036_l1048_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1036_l1048_action_invoke"); + let result = instance.call("lt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1049 +fn c1037_l1049_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1037_l1049_action_invoke"); + let result = instance.call("lt", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1050 +fn c1038_l1050_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1038_l1050_action_invoke"); + let result = instance.call("lt", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1051 +fn c1039_l1051_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1039_l1051_action_invoke"); + let result = instance.call("lt", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1052 +fn c1040_l1052_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1040_l1052_action_invoke"); + let result = instance.call("lt", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1053 +fn c1041_l1053_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1041_l1053_action_invoke"); + let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1054 +fn c1042_l1054_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1042_l1054_action_invoke"); + let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1055 +fn c1043_l1055_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1043_l1055_action_invoke"); + let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1056 +fn c1044_l1056_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1044_l1056_action_invoke"); + let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1057 +fn c1045_l1057_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1045_l1057_action_invoke"); + let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1058 +fn c1046_l1058_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1046_l1058_action_invoke"); + let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1059 +fn c1047_l1059_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1047_l1059_action_invoke"); + let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1060 +fn c1048_l1060_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1048_l1060_action_invoke"); + let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1061 +fn c1049_l1061_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1049_l1061_action_invoke"); + let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1062 +fn c1050_l1062_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1050_l1062_action_invoke"); + let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1063 +fn c1051_l1063_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1051_l1063_action_invoke"); + let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1064 +fn c1052_l1064_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1052_l1064_action_invoke"); + let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1065 +fn c1053_l1065_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1053_l1065_action_invoke"); + let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1066 +fn c1054_l1066_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1054_l1066_action_invoke"); + let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1067 +fn c1055_l1067_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1055_l1067_action_invoke"); + let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1068 +fn c1056_l1068_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1056_l1068_action_invoke"); + let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1069 +fn c1057_l1069_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1057_l1069_action_invoke"); + let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1070 +fn c1058_l1070_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1058_l1070_action_invoke"); + let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1071 +fn c1059_l1071_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1059_l1071_action_invoke"); + let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1072 +fn c1060_l1072_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1060_l1072_action_invoke"); + let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1073 +fn c1061_l1073_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1061_l1073_action_invoke"); + let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1074 +fn c1062_l1074_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1062_l1074_action_invoke"); + let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1075 +fn c1063_l1075_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1063_l1075_action_invoke"); + let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1076 +fn c1064_l1076_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1064_l1076_action_invoke"); + let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1077 +fn c1065_l1077_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1065_l1077_action_invoke"); + let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1078 +fn c1066_l1078_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1066_l1078_action_invoke"); + let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1079 +fn c1067_l1079_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1067_l1079_action_invoke"); + let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1080 +fn c1068_l1080_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1068_l1080_action_invoke"); + let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1081 +fn c1069_l1081_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1069_l1081_action_invoke"); + let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1082 +fn c1070_l1082_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1070_l1082_action_invoke"); + let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1083 +fn c1071_l1083_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1071_l1083_action_invoke"); + let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1084 +fn c1072_l1084_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1072_l1084_action_invoke"); + let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1085 +fn c1073_l1085_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1073_l1085_action_invoke"); + let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1086 +fn c1074_l1086_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1074_l1086_action_invoke"); + let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1087 +fn c1075_l1087_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1075_l1087_action_invoke"); + let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1088 +fn c1076_l1088_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1076_l1088_action_invoke"); + let result = instance.call("lt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1089 +fn c1077_l1089_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1077_l1089_action_invoke"); + let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1090 +fn c1078_l1090_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1078_l1090_action_invoke"); + let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1091 +fn c1079_l1091_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1079_l1091_action_invoke"); + let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1092 +fn c1080_l1092_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1080_l1092_action_invoke"); + let result = instance.call("lt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1093 +fn c1081_l1093_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1081_l1093_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1094 +fn c1082_l1094_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1082_l1094_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1095 +fn c1083_l1095_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1083_l1095_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1096 +fn c1084_l1096_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1084_l1096_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1097 +fn c1085_l1097_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1085_l1097_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1098 +fn c1086_l1098_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1086_l1098_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1099 +fn c1087_l1099_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1087_l1099_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1100 +fn c1088_l1100_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1088_l1100_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1101 +fn c1089_l1101_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1089_l1101_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1102 +fn c1090_l1102_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1090_l1102_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1103 +fn c1091_l1103_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1091_l1103_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1104 +fn c1092_l1104_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1092_l1104_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1105 +fn c1093_l1105_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1093_l1105_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1106 +fn c1094_l1106_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1094_l1106_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1107 +fn c1095_l1107_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1095_l1107_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1108 +fn c1096_l1108_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1096_l1108_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1109 +fn c1097_l1109_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1097_l1109_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1110 +fn c1098_l1110_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1098_l1110_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1111 +fn c1099_l1111_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1099_l1111_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1112 +fn c1100_l1112_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1100_l1112_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1113 +fn c1101_l1113_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1101_l1113_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1114 +fn c1102_l1114_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1102_l1114_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1115 +fn c1103_l1115_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1103_l1115_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1116 +fn c1104_l1116_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1104_l1116_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1117 +fn c1105_l1117_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1105_l1117_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1118 +fn c1106_l1118_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1106_l1118_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1119 +fn c1107_l1119_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1107_l1119_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1120 +fn c1108_l1120_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1108_l1120_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1121 +fn c1109_l1121_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1109_l1121_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1122 +fn c1110_l1122_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1110_l1122_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1123 +fn c1111_l1123_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1111_l1123_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1124 +fn c1112_l1124_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1112_l1124_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1125 +fn c1113_l1125_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1113_l1125_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1126 +fn c1114_l1126_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1114_l1126_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1127 +fn c1115_l1127_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1115_l1127_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1128 +fn c1116_l1128_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1116_l1128_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1129 +fn c1117_l1129_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1117_l1129_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1130 +fn c1118_l1130_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1118_l1130_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1131 +fn c1119_l1131_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1119_l1131_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1132 +fn c1120_l1132_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1120_l1132_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1133 +fn c1121_l1133_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1121_l1133_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1134 +fn c1122_l1134_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1122_l1134_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1135 +fn c1123_l1135_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1123_l1135_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1136 +fn c1124_l1136_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1124_l1136_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1137 +fn c1125_l1137_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1125_l1137_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1138 +fn c1126_l1138_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1126_l1138_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1139 +fn c1127_l1139_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1127_l1139_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1140 +fn c1128_l1140_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1128_l1140_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1141 +fn c1129_l1141_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1129_l1141_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1142 +fn c1130_l1142_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1130_l1142_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1143 +fn c1131_l1143_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1131_l1143_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1144 +fn c1132_l1144_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1132_l1144_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1145 +fn c1133_l1145_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1133_l1145_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1146 +fn c1134_l1146_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1134_l1146_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1147 +fn c1135_l1147_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1135_l1147_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1148 +fn c1136_l1148_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1136_l1148_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1149 +fn c1137_l1149_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1137_l1149_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1150 +fn c1138_l1150_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1138_l1150_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1151 +fn c1139_l1151_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1139_l1151_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1152 +fn c1140_l1152_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1140_l1152_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1153 +fn c1141_l1153_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1141_l1153_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1154 +fn c1142_l1154_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1142_l1154_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1155 +fn c1143_l1155_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1143_l1155_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1156 +fn c1144_l1156_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1144_l1156_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1157 +fn c1145_l1157_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1145_l1157_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1158 +fn c1146_l1158_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1146_l1158_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1159 +fn c1147_l1159_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1147_l1159_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1160 +fn c1148_l1160_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1148_l1160_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1161 +fn c1149_l1161_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1149_l1161_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1162 +fn c1150_l1162_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1150_l1162_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1163 +fn c1151_l1163_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1151_l1163_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1164 +fn c1152_l1164_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1152_l1164_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1165 +fn c1153_l1165_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1153_l1165_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1166 +fn c1154_l1166_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1154_l1166_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1167 +fn c1155_l1167_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1155_l1167_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1168 +fn c1156_l1168_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1156_l1168_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1169 +fn c1157_l1169_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1157_l1169_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1170 +fn c1158_l1170_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1158_l1170_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1171 +fn c1159_l1171_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1159_l1171_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1172 +fn c1160_l1172_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1160_l1172_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1173 +fn c1161_l1173_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1161_l1173_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1174 +fn c1162_l1174_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1162_l1174_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1175 +fn c1163_l1175_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1163_l1175_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1176 +fn c1164_l1176_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1164_l1176_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1177 +fn c1165_l1177_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1165_l1177_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1178 +fn c1166_l1178_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1166_l1178_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1179 +fn c1167_l1179_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1167_l1179_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1180 +fn c1168_l1180_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1168_l1180_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1181 +fn c1169_l1181_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1169_l1181_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1182 +fn c1170_l1182_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1170_l1182_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1183 +fn c1171_l1183_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1171_l1183_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1184 +fn c1172_l1184_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1172_l1184_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1185 +fn c1173_l1185_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1173_l1185_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1186 +fn c1174_l1186_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1174_l1186_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1187 +fn c1175_l1187_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1175_l1187_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1188 +fn c1176_l1188_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1176_l1188_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1189 +fn c1177_l1189_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1177_l1189_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1190 +fn c1178_l1190_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1178_l1190_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1191 +fn c1179_l1191_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1179_l1191_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1192 +fn c1180_l1192_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1180_l1192_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1193 +fn c1181_l1193_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1181_l1193_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1194 +fn c1182_l1194_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1182_l1194_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1195 +fn c1183_l1195_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1183_l1195_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1196 +fn c1184_l1196_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1184_l1196_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1197 +fn c1185_l1197_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1185_l1197_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1198 +fn c1186_l1198_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1186_l1198_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1199 +fn c1187_l1199_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1187_l1199_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1200 +fn c1188_l1200_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1188_l1200_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1201 +fn c1189_l1201_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1189_l1201_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1202 +fn c1190_l1202_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1190_l1202_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1203 +fn c1191_l1203_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1191_l1203_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1204 +fn c1192_l1204_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1192_l1204_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1205 +fn c1193_l1205_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1193_l1205_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1206 +fn c1194_l1206_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1194_l1206_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1207 +fn c1195_l1207_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1195_l1207_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1208 +fn c1196_l1208_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1196_l1208_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1209 +fn c1197_l1209_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1197_l1209_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1210 +fn c1198_l1210_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1198_l1210_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1211 +fn c1199_l1211_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1199_l1211_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1212 +fn c1200_l1212_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1200_l1212_action_invoke"); + let result = instance.call("lt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1213 +fn c1201_l1213_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1201_l1213_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1214 +fn c1202_l1214_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1202_l1214_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1215 +fn c1203_l1215_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1203_l1215_action_invoke"); + let result = instance.call("le", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1216 +fn c1204_l1216_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1204_l1216_action_invoke"); + let result = instance.call("le", &[Value::F32((0.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1217 +fn c1205_l1217_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1205_l1217_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1218 +fn c1206_l1218_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1206_l1218_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1219 +fn c1207_l1219_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1207_l1219_action_invoke"); + let result = instance.call("le", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1220 +fn c1208_l1220_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1208_l1220_action_invoke"); + let result = instance.call("le", &[Value::F32((0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1221 +fn c1209_l1221_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1209_l1221_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1222 +fn c1210_l1222_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1210_l1222_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1223 +fn c1211_l1223_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1211_l1223_action_invoke"); + let result = instance.call("le", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1224 +fn c1212_l1224_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1212_l1224_action_invoke"); + let result = instance.call("le", &[Value::F32((0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1225 +fn c1213_l1225_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1213_l1225_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1226 +fn c1214_l1226_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1214_l1226_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1227 +fn c1215_l1227_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1215_l1227_action_invoke"); + let result = instance.call("le", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1228 +fn c1216_l1228_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1216_l1228_action_invoke"); + let result = instance.call("le", &[Value::F32((0.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1229 +fn c1217_l1229_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1217_l1229_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1230 +fn c1218_l1230_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1218_l1230_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1231 +fn c1219_l1231_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1219_l1231_action_invoke"); + let result = instance.call("le", &[Value::F32((0.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1232 +fn c1220_l1232_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1220_l1232_action_invoke"); + let result = instance.call("le", &[Value::F32((0.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1233 +fn c1221_l1233_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1221_l1233_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1234 +fn c1222_l1234_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1222_l1234_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1235 +fn c1223_l1235_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1223_l1235_action_invoke"); + let result = instance.call("le", &[Value::F32((0.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1236 +fn c1224_l1236_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1224_l1236_action_invoke"); + let result = instance.call("le", &[Value::F32((0.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1237 +fn c1225_l1237_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1225_l1237_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1238 +fn c1226_l1238_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1226_l1238_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1239 +fn c1227_l1239_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1227_l1239_action_invoke"); + let result = instance.call("le", &[Value::F32((0.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1240 +fn c1228_l1240_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1228_l1240_action_invoke"); + let result = instance.call("le", &[Value::F32((0.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1241 +fn c1229_l1241_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1229_l1241_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1242 +fn c1230_l1242_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1230_l1242_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1243 +fn c1231_l1243_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1231_l1243_action_invoke"); + let result = instance.call("le", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1244 +fn c1232_l1244_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1232_l1244_action_invoke"); + let result = instance.call("le", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1245 +fn c1233_l1245_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1233_l1245_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1246 +fn c1234_l1246_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1234_l1246_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1247 +fn c1235_l1247_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1235_l1247_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1248 +fn c1236_l1248_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1236_l1248_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1249 +fn c1237_l1249_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1237_l1249_action_invoke"); + let result = instance.call("le", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1250 +fn c1238_l1250_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1238_l1250_action_invoke"); + let result = instance.call("le", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1251 +fn c1239_l1251_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1239_l1251_action_invoke"); + let result = instance.call("le", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1252 +fn c1240_l1252_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1240_l1252_action_invoke"); + let result = instance.call("le", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1253 +fn c1241_l1253_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1241_l1253_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1254 +fn c1242_l1254_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1242_l1254_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1255 +fn c1243_l1255_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1243_l1255_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1256 +fn c1244_l1256_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1244_l1256_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1257 +fn c1245_l1257_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1245_l1257_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1258 +fn c1246_l1258_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1246_l1258_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1259 +fn c1247_l1259_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1247_l1259_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1260 +fn c1248_l1260_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1248_l1260_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1261 +fn c1249_l1261_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1249_l1261_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1262 +fn c1250_l1262_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1250_l1262_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1263 +fn c1251_l1263_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1251_l1263_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1264 +fn c1252_l1264_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1252_l1264_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1265 +fn c1253_l1265_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1253_l1265_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1266 +fn c1254_l1266_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1254_l1266_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1267 +fn c1255_l1267_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1255_l1267_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1268 +fn c1256_l1268_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1256_l1268_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1269 +fn c1257_l1269_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1257_l1269_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1270 +fn c1258_l1270_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1258_l1270_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1271 +fn c1259_l1271_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1259_l1271_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1272 +fn c1260_l1272_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1260_l1272_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1273 +fn c1261_l1273_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1261_l1273_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1274 +fn c1262_l1274_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1262_l1274_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1275 +fn c1263_l1275_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1263_l1275_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1276 +fn c1264_l1276_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1264_l1276_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1277 +fn c1265_l1277_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1265_l1277_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1278 +fn c1266_l1278_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1266_l1278_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1279 +fn c1267_l1279_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1267_l1279_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1280 +fn c1268_l1280_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1268_l1280_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1281 +fn c1269_l1281_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1269_l1281_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1282 +fn c1270_l1282_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1270_l1282_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1283 +fn c1271_l1283_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1271_l1283_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1284 +fn c1272_l1284_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1272_l1284_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1285 +fn c1273_l1285_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1273_l1285_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1286 +fn c1274_l1286_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1274_l1286_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1287 +fn c1275_l1287_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1275_l1287_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1288 +fn c1276_l1288_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1276_l1288_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1289 +fn c1277_l1289_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1277_l1289_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1290 +fn c1278_l1290_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1278_l1290_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1291 +fn c1279_l1291_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1279_l1291_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1292 +fn c1280_l1292_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1280_l1292_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1293 +fn c1281_l1293_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1281_l1293_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1294 +fn c1282_l1294_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1282_l1294_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1295 +fn c1283_l1295_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1283_l1295_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1296 +fn c1284_l1296_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1284_l1296_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1297 +fn c1285_l1297_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1285_l1297_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1298 +fn c1286_l1298_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1286_l1298_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1299 +fn c1287_l1299_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1287_l1299_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1300 +fn c1288_l1300_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1288_l1300_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1301 +fn c1289_l1301_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1289_l1301_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1302 +fn c1290_l1302_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1290_l1302_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1303 +fn c1291_l1303_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1291_l1303_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1304 +fn c1292_l1304_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1292_l1304_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1305 +fn c1293_l1305_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1293_l1305_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1306 +fn c1294_l1306_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1294_l1306_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1307 +fn c1295_l1307_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1295_l1307_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1308 +fn c1296_l1308_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1296_l1308_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1309 +fn c1297_l1309_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1297_l1309_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1310 +fn c1298_l1310_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1298_l1310_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1311 +fn c1299_l1311_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1299_l1311_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1312 +fn c1300_l1312_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1300_l1312_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1313 +fn c1301_l1313_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1301_l1313_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1314 +fn c1302_l1314_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1302_l1314_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1315 +fn c1303_l1315_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1303_l1315_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1316 +fn c1304_l1316_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1304_l1316_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1317 +fn c1305_l1317_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1305_l1317_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1318 +fn c1306_l1318_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1306_l1318_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1319 +fn c1307_l1319_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1307_l1319_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1320 +fn c1308_l1320_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1308_l1320_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1321 +fn c1309_l1321_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1309_l1321_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1322 +fn c1310_l1322_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1310_l1322_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1323 +fn c1311_l1323_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1311_l1323_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1324 +fn c1312_l1324_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1312_l1324_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1325 +fn c1313_l1325_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1313_l1325_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1326 +fn c1314_l1326_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1314_l1326_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1327 +fn c1315_l1327_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1315_l1327_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1328 +fn c1316_l1328_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1316_l1328_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1329 +fn c1317_l1329_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1317_l1329_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1330 +fn c1318_l1330_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1318_l1330_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1331 +fn c1319_l1331_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1319_l1331_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1332 +fn c1320_l1332_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1320_l1332_action_invoke"); + let result = instance.call("le", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1333 +fn c1321_l1333_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1321_l1333_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1334 +fn c1322_l1334_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1322_l1334_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1335 +fn c1323_l1335_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1323_l1335_action_invoke"); + let result = instance.call("le", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1336 +fn c1324_l1336_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1324_l1336_action_invoke"); + let result = instance.call("le", &[Value::F32((0.5f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1337 +fn c1325_l1337_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1325_l1337_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1338 +fn c1326_l1338_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1326_l1338_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1339 +fn c1327_l1339_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1327_l1339_action_invoke"); + let result = instance.call("le", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1340 +fn c1328_l1340_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1328_l1340_action_invoke"); + let result = instance.call("le", &[Value::F32((0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1341 +fn c1329_l1341_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1329_l1341_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1342 +fn c1330_l1342_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1330_l1342_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1343 +fn c1331_l1343_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1331_l1343_action_invoke"); + let result = instance.call("le", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1344 +fn c1332_l1344_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1332_l1344_action_invoke"); + let result = instance.call("le", &[Value::F32((0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1345 +fn c1333_l1345_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1333_l1345_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1346 +fn c1334_l1346_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1334_l1346_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1347 +fn c1335_l1347_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1335_l1347_action_invoke"); + let result = instance.call("le", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1348 +fn c1336_l1348_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1336_l1348_action_invoke"); + let result = instance.call("le", &[Value::F32((0.5f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1349 +fn c1337_l1349_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1337_l1349_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.5f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1350 +fn c1338_l1350_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1338_l1350_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.5f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1351 +fn c1339_l1351_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1339_l1351_action_invoke"); + let result = instance.call("le", &[Value::F32((0.5f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1352 +fn c1340_l1352_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1340_l1352_action_invoke"); + let result = instance.call("le", &[Value::F32((0.5f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1353 +fn c1341_l1353_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1341_l1353_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.5f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1354 +fn c1342_l1354_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1342_l1354_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.5f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1355 +fn c1343_l1355_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1343_l1355_action_invoke"); + let result = instance.call("le", &[Value::F32((0.5f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1356 +fn c1344_l1356_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1344_l1356_action_invoke"); + let result = instance.call("le", &[Value::F32((0.5f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1357 +fn c1345_l1357_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1345_l1357_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.5f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1358 +fn c1346_l1358_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1346_l1358_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.5f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1359 +fn c1347_l1359_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1347_l1359_action_invoke"); + let result = instance.call("le", &[Value::F32((0.5f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1360 +fn c1348_l1360_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1348_l1360_action_invoke"); + let result = instance.call("le", &[Value::F32((0.5f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1361 +fn c1349_l1361_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1349_l1361_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1362 +fn c1350_l1362_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1350_l1362_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1363 +fn c1351_l1363_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1351_l1363_action_invoke"); + let result = instance.call("le", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1364 +fn c1352_l1364_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1352_l1364_action_invoke"); + let result = instance.call("le", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1365 +fn c1353_l1365_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1353_l1365_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1366 +fn c1354_l1366_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1354_l1366_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1367 +fn c1355_l1367_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1355_l1367_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1368 +fn c1356_l1368_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1356_l1368_action_invoke"); + let result = instance.call("le", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1369 +fn c1357_l1369_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1357_l1369_action_invoke"); + let result = instance.call("le", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1370 +fn c1358_l1370_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1358_l1370_action_invoke"); + let result = instance.call("le", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1371 +fn c1359_l1371_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1359_l1371_action_invoke"); + let result = instance.call("le", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1372 +fn c1360_l1372_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1360_l1372_action_invoke"); + let result = instance.call("le", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1373 +fn c1361_l1373_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1361_l1373_action_invoke"); + let result = instance.call("le", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1374 +fn c1362_l1374_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1362_l1374_action_invoke"); + let result = instance.call("le", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1375 +fn c1363_l1375_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1363_l1375_action_invoke"); + let result = instance.call("le", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1376 +fn c1364_l1376_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1364_l1376_action_invoke"); + let result = instance.call("le", &[Value::F32((1.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1377 +fn c1365_l1377_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1365_l1377_action_invoke"); + let result = instance.call("le", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1378 +fn c1366_l1378_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1366_l1378_action_invoke"); + let result = instance.call("le", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1379 +fn c1367_l1379_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1367_l1379_action_invoke"); + let result = instance.call("le", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1380 +fn c1368_l1380_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1368_l1380_action_invoke"); + let result = instance.call("le", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1381 +fn c1369_l1381_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1369_l1381_action_invoke"); + let result = instance.call("le", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1382 +fn c1370_l1382_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1370_l1382_action_invoke"); + let result = instance.call("le", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1383 +fn c1371_l1383_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1371_l1383_action_invoke"); + let result = instance.call("le", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1384 +fn c1372_l1384_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1372_l1384_action_invoke"); + let result = instance.call("le", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1385 +fn c1373_l1385_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1373_l1385_action_invoke"); + let result = instance.call("le", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1386 +fn c1374_l1386_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1374_l1386_action_invoke"); + let result = instance.call("le", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1387 +fn c1375_l1387_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1375_l1387_action_invoke"); + let result = instance.call("le", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1388 +fn c1376_l1388_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1376_l1388_action_invoke"); + let result = instance.call("le", &[Value::F32((1.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1389 +fn c1377_l1389_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1377_l1389_action_invoke"); + let result = instance.call("le", &[Value::F32((-1.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1390 +fn c1378_l1390_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1378_l1390_action_invoke"); + let result = instance.call("le", &[Value::F32((-1.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1391 +fn c1379_l1391_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1379_l1391_action_invoke"); + let result = instance.call("le", &[Value::F32((1.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1392 +fn c1380_l1392_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1380_l1392_action_invoke"); + let result = instance.call("le", &[Value::F32((1.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1393 +fn c1381_l1393_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1381_l1393_action_invoke"); + let result = instance.call("le", &[Value::F32((-1.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1394 +fn c1382_l1394_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1382_l1394_action_invoke"); + let result = instance.call("le", &[Value::F32((-1.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1395 +fn c1383_l1395_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1383_l1395_action_invoke"); + let result = instance.call("le", &[Value::F32((1.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1396 +fn c1384_l1396_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1384_l1396_action_invoke"); + let result = instance.call("le", &[Value::F32((1.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1397 +fn c1385_l1397_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1385_l1397_action_invoke"); + let result = instance.call("le", &[Value::F32((-1.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1398 +fn c1386_l1398_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1386_l1398_action_invoke"); + let result = instance.call("le", &[Value::F32((-1.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1399 +fn c1387_l1399_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1387_l1399_action_invoke"); + let result = instance.call("le", &[Value::F32((1.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1400 +fn c1388_l1400_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1388_l1400_action_invoke"); + let result = instance.call("le", &[Value::F32((1.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1401 +fn c1389_l1401_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1389_l1401_action_invoke"); + let result = instance.call("le", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1402 +fn c1390_l1402_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1390_l1402_action_invoke"); + let result = instance.call("le", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1403 +fn c1391_l1403_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1391_l1403_action_invoke"); + let result = instance.call("le", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1404 +fn c1392_l1404_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1392_l1404_action_invoke"); + let result = instance.call("le", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1405 +fn c1393_l1405_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1393_l1405_action_invoke"); + let result = instance.call("le", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1406 +fn c1394_l1406_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1394_l1406_action_invoke"); + let result = instance.call("le", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1407 +fn c1395_l1407_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1395_l1407_action_invoke"); + let result = instance.call("le", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1408 +fn c1396_l1408_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1396_l1408_action_invoke"); + let result = instance.call("le", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1409 +fn c1397_l1409_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1397_l1409_action_invoke"); + let result = instance.call("le", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1410 +fn c1398_l1410_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1398_l1410_action_invoke"); + let result = instance.call("le", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1411 +fn c1399_l1411_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1399_l1411_action_invoke"); + let result = instance.call("le", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1412 +fn c1400_l1412_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1400_l1412_action_invoke"); + let result = instance.call("le", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1413 +fn c1401_l1413_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1401_l1413_action_invoke"); + let result = instance.call("le", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1414 +fn c1402_l1414_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1402_l1414_action_invoke"); + let result = instance.call("le", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1415 +fn c1403_l1415_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1403_l1415_action_invoke"); + let result = instance.call("le", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1416 +fn c1404_l1416_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1404_l1416_action_invoke"); + let result = instance.call("le", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1417 +fn c1405_l1417_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1405_l1417_action_invoke"); + let result = instance.call("le", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1418 +fn c1406_l1418_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1406_l1418_action_invoke"); + let result = instance.call("le", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1419 +fn c1407_l1419_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1407_l1419_action_invoke"); + let result = instance.call("le", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1420 +fn c1408_l1420_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1408_l1420_action_invoke"); + let result = instance.call("le", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1421 +fn c1409_l1421_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1409_l1421_action_invoke"); + let result = instance.call("le", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1422 +fn c1410_l1422_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1410_l1422_action_invoke"); + let result = instance.call("le", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1423 +fn c1411_l1423_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1411_l1423_action_invoke"); + let result = instance.call("le", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1424 +fn c1412_l1424_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1412_l1424_action_invoke"); + let result = instance.call("le", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1425 +fn c1413_l1425_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1413_l1425_action_invoke"); + let result = instance.call("le", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1426 +fn c1414_l1426_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1414_l1426_action_invoke"); + let result = instance.call("le", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1427 +fn c1415_l1427_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1415_l1427_action_invoke"); + let result = instance.call("le", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1428 +fn c1416_l1428_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1416_l1428_action_invoke"); + let result = instance.call("le", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1429 +fn c1417_l1429_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1417_l1429_action_invoke"); + let result = instance.call("le", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1430 +fn c1418_l1430_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1418_l1430_action_invoke"); + let result = instance.call("le", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1431 +fn c1419_l1431_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1419_l1431_action_invoke"); + let result = instance.call("le", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1432 +fn c1420_l1432_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1420_l1432_action_invoke"); + let result = instance.call("le", &[Value::F32((6.2831855f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1433 +fn c1421_l1433_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1421_l1433_action_invoke"); + let result = instance.call("le", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1434 +fn c1422_l1434_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1422_l1434_action_invoke"); + let result = instance.call("le", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1435 +fn c1423_l1435_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1423_l1435_action_invoke"); + let result = instance.call("le", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1436 +fn c1424_l1436_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1424_l1436_action_invoke"); + let result = instance.call("le", &[Value::F32((6.2831855f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1437 +fn c1425_l1437_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1425_l1437_action_invoke"); + let result = instance.call("le", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1438 +fn c1426_l1438_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1426_l1438_action_invoke"); + let result = instance.call("le", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1439 +fn c1427_l1439_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1427_l1439_action_invoke"); + let result = instance.call("le", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1440 +fn c1428_l1440_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1428_l1440_action_invoke"); + let result = instance.call("le", &[Value::F32((6.2831855f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1441 +fn c1429_l1441_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1429_l1441_action_invoke"); + let result = instance.call("le", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1442 +fn c1430_l1442_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1430_l1442_action_invoke"); + let result = instance.call("le", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1443 +fn c1431_l1443_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1431_l1443_action_invoke"); + let result = instance.call("le", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1444 +fn c1432_l1444_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1432_l1444_action_invoke"); + let result = instance.call("le", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1445 +fn c1433_l1445_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1433_l1445_action_invoke"); + let result = instance.call("le", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1446 +fn c1434_l1446_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1434_l1446_action_invoke"); + let result = instance.call("le", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1447 +fn c1435_l1447_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1435_l1447_action_invoke"); + let result = instance.call("le", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1448 +fn c1436_l1448_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1436_l1448_action_invoke"); + let result = instance.call("le", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1449 +fn c1437_l1449_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1437_l1449_action_invoke"); + let result = instance.call("le", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1450 +fn c1438_l1450_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1438_l1450_action_invoke"); + let result = instance.call("le", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1451 +fn c1439_l1451_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1439_l1451_action_invoke"); + let result = instance.call("le", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1452 +fn c1440_l1452_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1440_l1452_action_invoke"); + let result = instance.call("le", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1453 +fn c1441_l1453_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1441_l1453_action_invoke"); + let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1454 +fn c1442_l1454_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1442_l1454_action_invoke"); + let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1455 +fn c1443_l1455_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1443_l1455_action_invoke"); + let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1456 +fn c1444_l1456_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1444_l1456_action_invoke"); + let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1457 +fn c1445_l1457_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1445_l1457_action_invoke"); + let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1458 +fn c1446_l1458_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1446_l1458_action_invoke"); + let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1459 +fn c1447_l1459_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1447_l1459_action_invoke"); + let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1460 +fn c1448_l1460_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1448_l1460_action_invoke"); + let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1461 +fn c1449_l1461_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1449_l1461_action_invoke"); + let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1462 +fn c1450_l1462_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1450_l1462_action_invoke"); + let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1463 +fn c1451_l1463_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1451_l1463_action_invoke"); + let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1464 +fn c1452_l1464_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1452_l1464_action_invoke"); + let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1465 +fn c1453_l1465_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1453_l1465_action_invoke"); + let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1466 +fn c1454_l1466_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1454_l1466_action_invoke"); + let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1467 +fn c1455_l1467_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1455_l1467_action_invoke"); + let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1468 +fn c1456_l1468_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1456_l1468_action_invoke"); + let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1469 +fn c1457_l1469_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1457_l1469_action_invoke"); + let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1470 +fn c1458_l1470_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1458_l1470_action_invoke"); + let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1471 +fn c1459_l1471_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1459_l1471_action_invoke"); + let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1472 +fn c1460_l1472_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1460_l1472_action_invoke"); + let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1473 +fn c1461_l1473_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1461_l1473_action_invoke"); + let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1474 +fn c1462_l1474_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1462_l1474_action_invoke"); + let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1475 +fn c1463_l1475_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1463_l1475_action_invoke"); + let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1476 +fn c1464_l1476_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1464_l1476_action_invoke"); + let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1477 +fn c1465_l1477_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1465_l1477_action_invoke"); + let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1478 +fn c1466_l1478_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1466_l1478_action_invoke"); + let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1479 +fn c1467_l1479_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1467_l1479_action_invoke"); + let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1480 +fn c1468_l1480_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1468_l1480_action_invoke"); + let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1481 +fn c1469_l1481_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1469_l1481_action_invoke"); + let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1482 +fn c1470_l1482_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1470_l1482_action_invoke"); + let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1483 +fn c1471_l1483_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1471_l1483_action_invoke"); + let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1484 +fn c1472_l1484_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1472_l1484_action_invoke"); + let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1485 +fn c1473_l1485_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1473_l1485_action_invoke"); + let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1486 +fn c1474_l1486_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1474_l1486_action_invoke"); + let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1487 +fn c1475_l1487_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1475_l1487_action_invoke"); + let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1488 +fn c1476_l1488_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1476_l1488_action_invoke"); + let result = instance.call("le", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1489 +fn c1477_l1489_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1477_l1489_action_invoke"); + let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1490 +fn c1478_l1490_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1478_l1490_action_invoke"); + let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1491 +fn c1479_l1491_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1479_l1491_action_invoke"); + let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1492 +fn c1480_l1492_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1480_l1492_action_invoke"); + let result = instance.call("le", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1493 +fn c1481_l1493_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1481_l1493_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1494 +fn c1482_l1494_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1482_l1494_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1495 +fn c1483_l1495_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1483_l1495_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1496 +fn c1484_l1496_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1484_l1496_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1497 +fn c1485_l1497_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1485_l1497_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1498 +fn c1486_l1498_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1486_l1498_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1499 +fn c1487_l1499_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1487_l1499_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1500 +fn c1488_l1500_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1488_l1500_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1501 +fn c1489_l1501_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1489_l1501_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1502 +fn c1490_l1502_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1490_l1502_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1503 +fn c1491_l1503_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1491_l1503_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1504 +fn c1492_l1504_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1492_l1504_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1505 +fn c1493_l1505_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1493_l1505_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1506 +fn c1494_l1506_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1494_l1506_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1507 +fn c1495_l1507_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1495_l1507_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1508 +fn c1496_l1508_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1496_l1508_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1509 +fn c1497_l1509_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1497_l1509_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1510 +fn c1498_l1510_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1498_l1510_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1511 +fn c1499_l1511_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1499_l1511_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1512 +fn c1500_l1512_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1500_l1512_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1513 +fn c1501_l1513_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1501_l1513_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1514 +fn c1502_l1514_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1502_l1514_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1515 +fn c1503_l1515_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1503_l1515_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1516 +fn c1504_l1516_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1504_l1516_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1517 +fn c1505_l1517_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1505_l1517_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1518 +fn c1506_l1518_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1506_l1518_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1519 +fn c1507_l1519_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1507_l1519_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1520 +fn c1508_l1520_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1508_l1520_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1521 +fn c1509_l1521_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1509_l1521_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1522 +fn c1510_l1522_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1510_l1522_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1523 +fn c1511_l1523_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1511_l1523_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1524 +fn c1512_l1524_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1512_l1524_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1525 +fn c1513_l1525_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1513_l1525_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1526 +fn c1514_l1526_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1514_l1526_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1527 +fn c1515_l1527_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1515_l1527_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1528 +fn c1516_l1528_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1516_l1528_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1529 +fn c1517_l1529_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1517_l1529_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1530 +fn c1518_l1530_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1518_l1530_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1531 +fn c1519_l1531_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1519_l1531_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1532 +fn c1520_l1532_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1520_l1532_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1533 +fn c1521_l1533_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1521_l1533_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1534 +fn c1522_l1534_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1522_l1534_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1535 +fn c1523_l1535_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1523_l1535_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1536 +fn c1524_l1536_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1524_l1536_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1537 +fn c1525_l1537_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1525_l1537_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1538 +fn c1526_l1538_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1526_l1538_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1539 +fn c1527_l1539_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1527_l1539_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1540 +fn c1528_l1540_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1528_l1540_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1541 +fn c1529_l1541_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1529_l1541_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1542 +fn c1530_l1542_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1530_l1542_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1543 +fn c1531_l1543_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1531_l1543_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1544 +fn c1532_l1544_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1532_l1544_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1545 +fn c1533_l1545_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1533_l1545_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1546 +fn c1534_l1546_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1534_l1546_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1547 +fn c1535_l1547_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1535_l1547_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1548 +fn c1536_l1548_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1536_l1548_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1549 +fn c1537_l1549_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1537_l1549_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1550 +fn c1538_l1550_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1538_l1550_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1551 +fn c1539_l1551_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1539_l1551_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1552 +fn c1540_l1552_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1540_l1552_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1553 +fn c1541_l1553_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1541_l1553_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1554 +fn c1542_l1554_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1542_l1554_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1555 +fn c1543_l1555_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1543_l1555_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1556 +fn c1544_l1556_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1544_l1556_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1557 +fn c1545_l1557_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1545_l1557_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1558 +fn c1546_l1558_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1546_l1558_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1559 +fn c1547_l1559_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1547_l1559_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1560 +fn c1548_l1560_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1548_l1560_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1561 +fn c1549_l1561_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1549_l1561_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1562 +fn c1550_l1562_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1550_l1562_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1563 +fn c1551_l1563_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1551_l1563_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1564 +fn c1552_l1564_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1552_l1564_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1565 +fn c1553_l1565_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1553_l1565_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1566 +fn c1554_l1566_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1554_l1566_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1567 +fn c1555_l1567_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1555_l1567_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1568 +fn c1556_l1568_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1556_l1568_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1569 +fn c1557_l1569_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1557_l1569_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1570 +fn c1558_l1570_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1558_l1570_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1571 +fn c1559_l1571_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1559_l1571_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1572 +fn c1560_l1572_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1560_l1572_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1573 +fn c1561_l1573_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1561_l1573_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1574 +fn c1562_l1574_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1562_l1574_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1575 +fn c1563_l1575_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1563_l1575_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1576 +fn c1564_l1576_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1564_l1576_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1577 +fn c1565_l1577_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1565_l1577_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1578 +fn c1566_l1578_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1566_l1578_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1579 +fn c1567_l1579_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1567_l1579_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1580 +fn c1568_l1580_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1568_l1580_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1581 +fn c1569_l1581_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1569_l1581_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1582 +fn c1570_l1582_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1570_l1582_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1583 +fn c1571_l1583_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1571_l1583_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1584 +fn c1572_l1584_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1572_l1584_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1585 +fn c1573_l1585_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1573_l1585_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1586 +fn c1574_l1586_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1574_l1586_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1587 +fn c1575_l1587_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1575_l1587_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1588 +fn c1576_l1588_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1576_l1588_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1589 +fn c1577_l1589_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1577_l1589_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1590 +fn c1578_l1590_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1578_l1590_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1591 +fn c1579_l1591_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1579_l1591_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1592 +fn c1580_l1592_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1580_l1592_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1593 +fn c1581_l1593_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1581_l1593_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1594 +fn c1582_l1594_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1582_l1594_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1595 +fn c1583_l1595_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1583_l1595_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1596 +fn c1584_l1596_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1584_l1596_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1597 +fn c1585_l1597_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1585_l1597_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1598 +fn c1586_l1598_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1586_l1598_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1599 +fn c1587_l1599_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1587_l1599_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1600 +fn c1588_l1600_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1588_l1600_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1601 +fn c1589_l1601_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1589_l1601_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1602 +fn c1590_l1602_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1590_l1602_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1603 +fn c1591_l1603_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1591_l1603_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1604 +fn c1592_l1604_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1592_l1604_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1605 +fn c1593_l1605_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1593_l1605_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1606 +fn c1594_l1606_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1594_l1606_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1607 +fn c1595_l1607_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1595_l1607_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1608 +fn c1596_l1608_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1596_l1608_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1609 +fn c1597_l1609_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1597_l1609_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1610 +fn c1598_l1610_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1598_l1610_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1611 +fn c1599_l1611_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1599_l1611_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1612 +fn c1600_l1612_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1600_l1612_action_invoke"); + let result = instance.call("le", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1613 +fn c1601_l1613_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1601_l1613_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1614 +fn c1602_l1614_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1602_l1614_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1615 +fn c1603_l1615_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1603_l1615_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1616 +fn c1604_l1616_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1604_l1616_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1617 +fn c1605_l1617_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1605_l1617_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1618 +fn c1606_l1618_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1606_l1618_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1619 +fn c1607_l1619_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1607_l1619_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1620 +fn c1608_l1620_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1608_l1620_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1621 +fn c1609_l1621_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1609_l1621_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1622 +fn c1610_l1622_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1610_l1622_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1623 +fn c1611_l1623_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1611_l1623_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1624 +fn c1612_l1624_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1612_l1624_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1625 +fn c1613_l1625_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1613_l1625_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1626 +fn c1614_l1626_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1614_l1626_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1627 +fn c1615_l1627_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1615_l1627_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1628 +fn c1616_l1628_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1616_l1628_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1629 +fn c1617_l1629_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1617_l1629_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1630 +fn c1618_l1630_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1618_l1630_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1631 +fn c1619_l1631_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1619_l1631_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1632 +fn c1620_l1632_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1620_l1632_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1633 +fn c1621_l1633_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1621_l1633_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1634 +fn c1622_l1634_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1622_l1634_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1635 +fn c1623_l1635_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1623_l1635_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1636 +fn c1624_l1636_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1624_l1636_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1637 +fn c1625_l1637_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1625_l1637_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1638 +fn c1626_l1638_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1626_l1638_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1639 +fn c1627_l1639_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1627_l1639_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1640 +fn c1628_l1640_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1628_l1640_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1641 +fn c1629_l1641_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1629_l1641_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1642 +fn c1630_l1642_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1630_l1642_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1643 +fn c1631_l1643_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1631_l1643_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1644 +fn c1632_l1644_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1632_l1644_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1645 +fn c1633_l1645_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1633_l1645_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1646 +fn c1634_l1646_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1634_l1646_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1647 +fn c1635_l1647_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1635_l1647_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1648 +fn c1636_l1648_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1636_l1648_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1649 +fn c1637_l1649_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1637_l1649_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1650 +fn c1638_l1650_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1638_l1650_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1651 +fn c1639_l1651_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1639_l1651_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1652 +fn c1640_l1652_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1640_l1652_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1653 +fn c1641_l1653_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1641_l1653_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1654 +fn c1642_l1654_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1642_l1654_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1655 +fn c1643_l1655_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1643_l1655_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1656 +fn c1644_l1656_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1644_l1656_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1657 +fn c1645_l1657_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1645_l1657_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1658 +fn c1646_l1658_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1646_l1658_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1659 +fn c1647_l1659_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1647_l1659_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1660 +fn c1648_l1660_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1648_l1660_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1661 +fn c1649_l1661_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1649_l1661_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1662 +fn c1650_l1662_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1650_l1662_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1663 +fn c1651_l1663_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1651_l1663_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1664 +fn c1652_l1664_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1652_l1664_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1665 +fn c1653_l1665_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1653_l1665_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1666 +fn c1654_l1666_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1654_l1666_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1667 +fn c1655_l1667_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1655_l1667_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1668 +fn c1656_l1668_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1656_l1668_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1669 +fn c1657_l1669_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1657_l1669_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1670 +fn c1658_l1670_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1658_l1670_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1671 +fn c1659_l1671_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1659_l1671_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1672 +fn c1660_l1672_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1660_l1672_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1673 +fn c1661_l1673_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1661_l1673_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1674 +fn c1662_l1674_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1662_l1674_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1675 +fn c1663_l1675_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1663_l1675_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1676 +fn c1664_l1676_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1664_l1676_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1677 +fn c1665_l1677_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1665_l1677_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1678 +fn c1666_l1678_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1666_l1678_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1679 +fn c1667_l1679_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1667_l1679_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1680 +fn c1668_l1680_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1668_l1680_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1681 +fn c1669_l1681_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1669_l1681_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1682 +fn c1670_l1682_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1670_l1682_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1683 +fn c1671_l1683_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1671_l1683_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1684 +fn c1672_l1684_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1672_l1684_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1685 +fn c1673_l1685_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1673_l1685_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1686 +fn c1674_l1686_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1674_l1686_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1687 +fn c1675_l1687_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1675_l1687_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1688 +fn c1676_l1688_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1676_l1688_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1689 +fn c1677_l1689_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1677_l1689_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1690 +fn c1678_l1690_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1678_l1690_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1691 +fn c1679_l1691_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1679_l1691_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1692 +fn c1680_l1692_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1680_l1692_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1693 +fn c1681_l1693_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1681_l1693_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1694 +fn c1682_l1694_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1682_l1694_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1695 +fn c1683_l1695_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1683_l1695_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1696 +fn c1684_l1696_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1684_l1696_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1697 +fn c1685_l1697_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1685_l1697_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1698 +fn c1686_l1698_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1686_l1698_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1699 +fn c1687_l1699_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1687_l1699_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1700 +fn c1688_l1700_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1688_l1700_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1701 +fn c1689_l1701_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1689_l1701_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1702 +fn c1690_l1702_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1690_l1702_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1703 +fn c1691_l1703_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1691_l1703_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1704 +fn c1692_l1704_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1692_l1704_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1705 +fn c1693_l1705_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1693_l1705_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1706 +fn c1694_l1706_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1694_l1706_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1707 +fn c1695_l1707_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1695_l1707_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1708 +fn c1696_l1708_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1696_l1708_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1709 +fn c1697_l1709_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1697_l1709_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1710 +fn c1698_l1710_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1698_l1710_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1711 +fn c1699_l1711_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1699_l1711_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1712 +fn c1700_l1712_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1700_l1712_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1713 +fn c1701_l1713_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1701_l1713_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1714 +fn c1702_l1714_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1702_l1714_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1715 +fn c1703_l1715_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1703_l1715_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1716 +fn c1704_l1716_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1704_l1716_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1717 +fn c1705_l1717_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1705_l1717_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1718 +fn c1706_l1718_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1706_l1718_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1719 +fn c1707_l1719_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1707_l1719_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1720 +fn c1708_l1720_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1708_l1720_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1721 +fn c1709_l1721_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1709_l1721_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1722 +fn c1710_l1722_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1710_l1722_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1723 +fn c1711_l1723_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1711_l1723_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1724 +fn c1712_l1724_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1712_l1724_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1725 +fn c1713_l1725_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1713_l1725_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1726 +fn c1714_l1726_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1714_l1726_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1727 +fn c1715_l1727_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1715_l1727_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1728 +fn c1716_l1728_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1716_l1728_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1729 +fn c1717_l1729_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1717_l1729_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1730 +fn c1718_l1730_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1718_l1730_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1731 +fn c1719_l1731_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1719_l1731_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1732 +fn c1720_l1732_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1720_l1732_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1733 +fn c1721_l1733_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1721_l1733_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1734 +fn c1722_l1734_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1722_l1734_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1735 +fn c1723_l1735_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1723_l1735_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1736 +fn c1724_l1736_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1724_l1736_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.5f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1737 +fn c1725_l1737_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1725_l1737_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1738 +fn c1726_l1738_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1726_l1738_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1739 +fn c1727_l1739_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1727_l1739_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1740 +fn c1728_l1740_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1728_l1740_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1741 +fn c1729_l1741_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1729_l1741_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1742 +fn c1730_l1742_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1730_l1742_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1743 +fn c1731_l1743_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1731_l1743_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1744 +fn c1732_l1744_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1732_l1744_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1745 +fn c1733_l1745_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1733_l1745_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1746 +fn c1734_l1746_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1734_l1746_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1747 +fn c1735_l1747_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1735_l1747_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1748 +fn c1736_l1748_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1736_l1748_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.5f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1749 +fn c1737_l1749_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1737_l1749_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.5f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1750 +fn c1738_l1750_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1738_l1750_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.5f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1751 +fn c1739_l1751_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1739_l1751_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.5f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1752 +fn c1740_l1752_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1740_l1752_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.5f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1753 +fn c1741_l1753_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1741_l1753_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.5f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1754 +fn c1742_l1754_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1742_l1754_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.5f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1755 +fn c1743_l1755_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1743_l1755_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.5f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1756 +fn c1744_l1756_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1744_l1756_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.5f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1757 +fn c1745_l1757_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1745_l1757_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.5f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1758 +fn c1746_l1758_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1746_l1758_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.5f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1759 +fn c1747_l1759_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1747_l1759_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.5f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1760 +fn c1748_l1760_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1748_l1760_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.5f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1761 +fn c1749_l1761_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1749_l1761_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1762 +fn c1750_l1762_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1750_l1762_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1763 +fn c1751_l1763_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1751_l1763_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1764 +fn c1752_l1764_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1752_l1764_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1765 +fn c1753_l1765_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1753_l1765_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1766 +fn c1754_l1766_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1754_l1766_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1767 +fn c1755_l1767_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1755_l1767_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1768 +fn c1756_l1768_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1756_l1768_action_invoke"); + let result = instance.call("gt", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1769 +fn c1757_l1769_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1757_l1769_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1770 +fn c1758_l1770_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1758_l1770_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1771 +fn c1759_l1771_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1759_l1771_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1772 +fn c1760_l1772_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1760_l1772_action_invoke"); + let result = instance.call("gt", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1773 +fn c1761_l1773_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1761_l1773_action_invoke"); + let result = instance.call("gt", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1774 +fn c1762_l1774_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1762_l1774_action_invoke"); + let result = instance.call("gt", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1775 +fn c1763_l1775_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1763_l1775_action_invoke"); + let result = instance.call("gt", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1776 +fn c1764_l1776_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1764_l1776_action_invoke"); + let result = instance.call("gt", &[Value::F32((1.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1777 +fn c1765_l1777_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1765_l1777_action_invoke"); + let result = instance.call("gt", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1778 +fn c1766_l1778_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1766_l1778_action_invoke"); + let result = instance.call("gt", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1779 +fn c1767_l1779_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1767_l1779_action_invoke"); + let result = instance.call("gt", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1780 +fn c1768_l1780_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1768_l1780_action_invoke"); + let result = instance.call("gt", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1781 +fn c1769_l1781_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1769_l1781_action_invoke"); + let result = instance.call("gt", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1782 +fn c1770_l1782_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1770_l1782_action_invoke"); + let result = instance.call("gt", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1783 +fn c1771_l1783_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1771_l1783_action_invoke"); + let result = instance.call("gt", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1784 +fn c1772_l1784_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1772_l1784_action_invoke"); + let result = instance.call("gt", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1785 +fn c1773_l1785_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1773_l1785_action_invoke"); + let result = instance.call("gt", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1786 +fn c1774_l1786_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1774_l1786_action_invoke"); + let result = instance.call("gt", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1787 +fn c1775_l1787_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1775_l1787_action_invoke"); + let result = instance.call("gt", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1788 +fn c1776_l1788_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1776_l1788_action_invoke"); + let result = instance.call("gt", &[Value::F32((1.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1789 +fn c1777_l1789_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1777_l1789_action_invoke"); + let result = instance.call("gt", &[Value::F32((-1.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1790 +fn c1778_l1790_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1778_l1790_action_invoke"); + let result = instance.call("gt", &[Value::F32((-1.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1791 +fn c1779_l1791_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1779_l1791_action_invoke"); + let result = instance.call("gt", &[Value::F32((1.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1792 +fn c1780_l1792_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1780_l1792_action_invoke"); + let result = instance.call("gt", &[Value::F32((1.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1793 +fn c1781_l1793_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1781_l1793_action_invoke"); + let result = instance.call("gt", &[Value::F32((-1.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1794 +fn c1782_l1794_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1782_l1794_action_invoke"); + let result = instance.call("gt", &[Value::F32((-1.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1795 +fn c1783_l1795_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1783_l1795_action_invoke"); + let result = instance.call("gt", &[Value::F32((1.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1796 +fn c1784_l1796_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1784_l1796_action_invoke"); + let result = instance.call("gt", &[Value::F32((1.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1797 +fn c1785_l1797_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1785_l1797_action_invoke"); + let result = instance.call("gt", &[Value::F32((-1.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1798 +fn c1786_l1798_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1786_l1798_action_invoke"); + let result = instance.call("gt", &[Value::F32((-1.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1799 +fn c1787_l1799_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1787_l1799_action_invoke"); + let result = instance.call("gt", &[Value::F32((1.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1800 +fn c1788_l1800_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1788_l1800_action_invoke"); + let result = instance.call("gt", &[Value::F32((1.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1801 +fn c1789_l1801_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1789_l1801_action_invoke"); + let result = instance.call("gt", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1802 +fn c1790_l1802_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1790_l1802_action_invoke"); + let result = instance.call("gt", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1803 +fn c1791_l1803_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1791_l1803_action_invoke"); + let result = instance.call("gt", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1804 +fn c1792_l1804_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1792_l1804_action_invoke"); + let result = instance.call("gt", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1805 +fn c1793_l1805_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1793_l1805_action_invoke"); + let result = instance.call("gt", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1806 +fn c1794_l1806_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1794_l1806_action_invoke"); + let result = instance.call("gt", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1807 +fn c1795_l1807_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1795_l1807_action_invoke"); + let result = instance.call("gt", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1808 +fn c1796_l1808_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1796_l1808_action_invoke"); + let result = instance.call("gt", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1809 +fn c1797_l1809_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1797_l1809_action_invoke"); + let result = instance.call("gt", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1810 +fn c1798_l1810_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1798_l1810_action_invoke"); + let result = instance.call("gt", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1811 +fn c1799_l1811_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1799_l1811_action_invoke"); + let result = instance.call("gt", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1812 +fn c1800_l1812_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1800_l1812_action_invoke"); + let result = instance.call("gt", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1813 +fn c1801_l1813_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1801_l1813_action_invoke"); + let result = instance.call("gt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1814 +fn c1802_l1814_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1802_l1814_action_invoke"); + let result = instance.call("gt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1815 +fn c1803_l1815_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1803_l1815_action_invoke"); + let result = instance.call("gt", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1816 +fn c1804_l1816_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1804_l1816_action_invoke"); + let result = instance.call("gt", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1817 +fn c1805_l1817_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1805_l1817_action_invoke"); + let result = instance.call("gt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1818 +fn c1806_l1818_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1806_l1818_action_invoke"); + let result = instance.call("gt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1819 +fn c1807_l1819_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1807_l1819_action_invoke"); + let result = instance.call("gt", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1820 +fn c1808_l1820_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1808_l1820_action_invoke"); + let result = instance.call("gt", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1821 +fn c1809_l1821_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1809_l1821_action_invoke"); + let result = instance.call("gt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1822 +fn c1810_l1822_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1810_l1822_action_invoke"); + let result = instance.call("gt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1823 +fn c1811_l1823_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1811_l1823_action_invoke"); + let result = instance.call("gt", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1824 +fn c1812_l1824_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1812_l1824_action_invoke"); + let result = instance.call("gt", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1825 +fn c1813_l1825_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1813_l1825_action_invoke"); + let result = instance.call("gt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1826 +fn c1814_l1826_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1814_l1826_action_invoke"); + let result = instance.call("gt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1827 +fn c1815_l1827_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1815_l1827_action_invoke"); + let result = instance.call("gt", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1828 +fn c1816_l1828_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1816_l1828_action_invoke"); + let result = instance.call("gt", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1829 +fn c1817_l1829_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1817_l1829_action_invoke"); + let result = instance.call("gt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1830 +fn c1818_l1830_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1818_l1830_action_invoke"); + let result = instance.call("gt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1831 +fn c1819_l1831_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1819_l1831_action_invoke"); + let result = instance.call("gt", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1832 +fn c1820_l1832_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1820_l1832_action_invoke"); + let result = instance.call("gt", &[Value::F32((6.2831855f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1833 +fn c1821_l1833_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1821_l1833_action_invoke"); + let result = instance.call("gt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1834 +fn c1822_l1834_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1822_l1834_action_invoke"); + let result = instance.call("gt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1835 +fn c1823_l1835_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1823_l1835_action_invoke"); + let result = instance.call("gt", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1836 +fn c1824_l1836_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1824_l1836_action_invoke"); + let result = instance.call("gt", &[Value::F32((6.2831855f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1837 +fn c1825_l1837_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1825_l1837_action_invoke"); + let result = instance.call("gt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1838 +fn c1826_l1838_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1826_l1838_action_invoke"); + let result = instance.call("gt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1839 +fn c1827_l1839_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1827_l1839_action_invoke"); + let result = instance.call("gt", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1840 +fn c1828_l1840_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1828_l1840_action_invoke"); + let result = instance.call("gt", &[Value::F32((6.2831855f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1841 +fn c1829_l1841_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1829_l1841_action_invoke"); + let result = instance.call("gt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1842 +fn c1830_l1842_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1830_l1842_action_invoke"); + let result = instance.call("gt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1843 +fn c1831_l1843_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1831_l1843_action_invoke"); + let result = instance.call("gt", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1844 +fn c1832_l1844_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1832_l1844_action_invoke"); + let result = instance.call("gt", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1845 +fn c1833_l1845_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1833_l1845_action_invoke"); + let result = instance.call("gt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1846 +fn c1834_l1846_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1834_l1846_action_invoke"); + let result = instance.call("gt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1847 +fn c1835_l1847_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1835_l1847_action_invoke"); + let result = instance.call("gt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1848 +fn c1836_l1848_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1836_l1848_action_invoke"); + let result = instance.call("gt", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1849 +fn c1837_l1849_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1837_l1849_action_invoke"); + let result = instance.call("gt", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1850 +fn c1838_l1850_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1838_l1850_action_invoke"); + let result = instance.call("gt", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1851 +fn c1839_l1851_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1839_l1851_action_invoke"); + let result = instance.call("gt", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1852 +fn c1840_l1852_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1840_l1852_action_invoke"); + let result = instance.call("gt", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1853 +fn c1841_l1853_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1841_l1853_action_invoke"); + let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1854 +fn c1842_l1854_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1842_l1854_action_invoke"); + let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1855 +fn c1843_l1855_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1843_l1855_action_invoke"); + let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1856 +fn c1844_l1856_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1844_l1856_action_invoke"); + let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1857 +fn c1845_l1857_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1845_l1857_action_invoke"); + let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1858 +fn c1846_l1858_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1846_l1858_action_invoke"); + let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1859 +fn c1847_l1859_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1847_l1859_action_invoke"); + let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1860 +fn c1848_l1860_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1848_l1860_action_invoke"); + let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1861 +fn c1849_l1861_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1849_l1861_action_invoke"); + let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1862 +fn c1850_l1862_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1850_l1862_action_invoke"); + let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1863 +fn c1851_l1863_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1851_l1863_action_invoke"); + let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1864 +fn c1852_l1864_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1852_l1864_action_invoke"); + let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1865 +fn c1853_l1865_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1853_l1865_action_invoke"); + let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1866 +fn c1854_l1866_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1854_l1866_action_invoke"); + let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1867 +fn c1855_l1867_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1855_l1867_action_invoke"); + let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1868 +fn c1856_l1868_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1856_l1868_action_invoke"); + let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1869 +fn c1857_l1869_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1857_l1869_action_invoke"); + let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1870 +fn c1858_l1870_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1858_l1870_action_invoke"); + let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1871 +fn c1859_l1871_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1859_l1871_action_invoke"); + let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1872 +fn c1860_l1872_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1860_l1872_action_invoke"); + let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1873 +fn c1861_l1873_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1861_l1873_action_invoke"); + let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1874 +fn c1862_l1874_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1862_l1874_action_invoke"); + let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1875 +fn c1863_l1875_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1863_l1875_action_invoke"); + let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1876 +fn c1864_l1876_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1864_l1876_action_invoke"); + let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1877 +fn c1865_l1877_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1865_l1877_action_invoke"); + let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1878 +fn c1866_l1878_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1866_l1878_action_invoke"); + let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1879 +fn c1867_l1879_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1867_l1879_action_invoke"); + let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1880 +fn c1868_l1880_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1868_l1880_action_invoke"); + let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1881 +fn c1869_l1881_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1869_l1881_action_invoke"); + let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1882 +fn c1870_l1882_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1870_l1882_action_invoke"); + let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1883 +fn c1871_l1883_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1871_l1883_action_invoke"); + let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1884 +fn c1872_l1884_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1872_l1884_action_invoke"); + let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1885 +fn c1873_l1885_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1873_l1885_action_invoke"); + let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1886 +fn c1874_l1886_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1874_l1886_action_invoke"); + let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1887 +fn c1875_l1887_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1875_l1887_action_invoke"); + let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1888 +fn c1876_l1888_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1876_l1888_action_invoke"); + let result = instance.call("gt", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1889 +fn c1877_l1889_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1877_l1889_action_invoke"); + let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1890 +fn c1878_l1890_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1878_l1890_action_invoke"); + let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1891 +fn c1879_l1891_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1879_l1891_action_invoke"); + let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1892 +fn c1880_l1892_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1880_l1892_action_invoke"); + let result = instance.call("gt", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1893 +fn c1881_l1893_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1881_l1893_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1894 +fn c1882_l1894_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1882_l1894_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1895 +fn c1883_l1895_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1883_l1895_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1896 +fn c1884_l1896_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1884_l1896_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1897 +fn c1885_l1897_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1885_l1897_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1898 +fn c1886_l1898_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1886_l1898_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1899 +fn c1887_l1899_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1887_l1899_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1900 +fn c1888_l1900_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1888_l1900_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1901 +fn c1889_l1901_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1889_l1901_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1902 +fn c1890_l1902_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1890_l1902_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1903 +fn c1891_l1903_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1891_l1903_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1904 +fn c1892_l1904_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1892_l1904_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1905 +fn c1893_l1905_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1893_l1905_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1906 +fn c1894_l1906_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1894_l1906_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1907 +fn c1895_l1907_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1895_l1907_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1908 +fn c1896_l1908_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1896_l1908_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1909 +fn c1897_l1909_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1897_l1909_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1910 +fn c1898_l1910_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1898_l1910_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1911 +fn c1899_l1911_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1899_l1911_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1912 +fn c1900_l1912_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1900_l1912_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1913 +fn c1901_l1913_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1901_l1913_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1914 +fn c1902_l1914_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1902_l1914_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1915 +fn c1903_l1915_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1903_l1915_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1916 +fn c1904_l1916_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1904_l1916_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1917 +fn c1905_l1917_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1905_l1917_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1918 +fn c1906_l1918_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1906_l1918_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1919 +fn c1907_l1919_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1907_l1919_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1920 +fn c1908_l1920_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1908_l1920_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1921 +fn c1909_l1921_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1909_l1921_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1922 +fn c1910_l1922_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1910_l1922_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1923 +fn c1911_l1923_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1911_l1923_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1924 +fn c1912_l1924_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1912_l1924_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1925 +fn c1913_l1925_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1913_l1925_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1926 +fn c1914_l1926_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1914_l1926_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1927 +fn c1915_l1927_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1915_l1927_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1928 +fn c1916_l1928_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1916_l1928_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1929 +fn c1917_l1929_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1917_l1929_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1930 +fn c1918_l1930_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1918_l1930_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1931 +fn c1919_l1931_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1919_l1931_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1932 +fn c1920_l1932_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1920_l1932_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1933 +fn c1921_l1933_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1921_l1933_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1934 +fn c1922_l1934_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1922_l1934_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1935 +fn c1923_l1935_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1923_l1935_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1936 +fn c1924_l1936_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1924_l1936_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1937 +fn c1925_l1937_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1925_l1937_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1938 +fn c1926_l1938_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1926_l1938_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1939 +fn c1927_l1939_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1927_l1939_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1940 +fn c1928_l1940_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1928_l1940_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1941 +fn c1929_l1941_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1929_l1941_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1942 +fn c1930_l1942_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1930_l1942_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1943 +fn c1931_l1943_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1931_l1943_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1944 +fn c1932_l1944_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1932_l1944_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1945 +fn c1933_l1945_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1933_l1945_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1946 +fn c1934_l1946_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1934_l1946_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1947 +fn c1935_l1947_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1935_l1947_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1948 +fn c1936_l1948_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1936_l1948_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1949 +fn c1937_l1949_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1937_l1949_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1950 +fn c1938_l1950_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1938_l1950_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1951 +fn c1939_l1951_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1939_l1951_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1952 +fn c1940_l1952_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1940_l1952_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1953 +fn c1941_l1953_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1941_l1953_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1954 +fn c1942_l1954_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1942_l1954_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1955 +fn c1943_l1955_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1943_l1955_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1956 +fn c1944_l1956_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1944_l1956_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1957 +fn c1945_l1957_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1945_l1957_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1958 +fn c1946_l1958_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1946_l1958_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1959 +fn c1947_l1959_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1947_l1959_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1960 +fn c1948_l1960_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1948_l1960_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1961 +fn c1949_l1961_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1949_l1961_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1962 +fn c1950_l1962_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1950_l1962_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1963 +fn c1951_l1963_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1951_l1963_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1964 +fn c1952_l1964_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1952_l1964_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1965 +fn c1953_l1965_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1953_l1965_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1966 +fn c1954_l1966_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1954_l1966_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1967 +fn c1955_l1967_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1955_l1967_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1968 +fn c1956_l1968_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1956_l1968_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1969 +fn c1957_l1969_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1957_l1969_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1970 +fn c1958_l1970_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1958_l1970_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1971 +fn c1959_l1971_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1959_l1971_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1972 +fn c1960_l1972_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1960_l1972_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1973 +fn c1961_l1973_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1961_l1973_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1974 +fn c1962_l1974_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1962_l1974_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1975 +fn c1963_l1975_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1963_l1975_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1976 +fn c1964_l1976_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1964_l1976_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1977 +fn c1965_l1977_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1965_l1977_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1978 +fn c1966_l1978_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1966_l1978_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1979 +fn c1967_l1979_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1967_l1979_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1980 +fn c1968_l1980_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1968_l1980_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1981 +fn c1969_l1981_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1969_l1981_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1982 +fn c1970_l1982_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1970_l1982_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1983 +fn c1971_l1983_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1971_l1983_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1984 +fn c1972_l1984_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1972_l1984_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1985 +fn c1973_l1985_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1973_l1985_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1986 +fn c1974_l1986_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1974_l1986_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1987 +fn c1975_l1987_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1975_l1987_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1988 +fn c1976_l1988_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1976_l1988_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1989 +fn c1977_l1989_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1977_l1989_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1990 +fn c1978_l1990_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1978_l1990_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1991 +fn c1979_l1991_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1979_l1991_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1992 +fn c1980_l1992_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1980_l1992_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1993 +fn c1981_l1993_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1981_l1993_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1994 +fn c1982_l1994_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1982_l1994_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1995 +fn c1983_l1995_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1983_l1995_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1996 +fn c1984_l1996_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1984_l1996_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1997 +fn c1985_l1997_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1985_l1997_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1998 +fn c1986_l1998_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1986_l1998_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1999 +fn c1987_l1999_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1987_l1999_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2000 +fn c1988_l2000_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1988_l2000_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2001 +fn c1989_l2001_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1989_l2001_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2002 +fn c1990_l2002_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1990_l2002_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2003 +fn c1991_l2003_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1991_l2003_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2004 +fn c1992_l2004_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1992_l2004_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2005 +fn c1993_l2005_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1993_l2005_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2006 +fn c1994_l2006_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1994_l2006_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2007 +fn c1995_l2007_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1995_l2007_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2008 +fn c1996_l2008_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1996_l2008_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2009 +fn c1997_l2009_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1997_l2009_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2010 +fn c1998_l2010_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1998_l2010_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2011 +fn c1999_l2011_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1999_l2011_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2012 +fn c2000_l2012_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2000_l2012_action_invoke"); + let result = instance.call("gt", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2013 +fn c2001_l2013_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2001_l2013_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2014 +fn c2002_l2014_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2002_l2014_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2015 +fn c2003_l2015_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2003_l2015_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2016 +fn c2004_l2016_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2004_l2016_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2017 +fn c2005_l2017_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2005_l2017_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2018 +fn c2006_l2018_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2006_l2018_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2019 +fn c2007_l2019_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2007_l2019_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2020 +fn c2008_l2020_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2008_l2020_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2021 +fn c2009_l2021_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2009_l2021_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2022 +fn c2010_l2022_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2010_l2022_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2023 +fn c2011_l2023_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2011_l2023_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2024 +fn c2012_l2024_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2012_l2024_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2025 +fn c2013_l2025_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2013_l2025_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2026 +fn c2014_l2026_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2014_l2026_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2027 +fn c2015_l2027_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2015_l2027_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2028 +fn c2016_l2028_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2016_l2028_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2029 +fn c2017_l2029_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2017_l2029_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2030 +fn c2018_l2030_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2018_l2030_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2031 +fn c2019_l2031_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2019_l2031_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2032 +fn c2020_l2032_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2020_l2032_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2033 +fn c2021_l2033_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2021_l2033_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2034 +fn c2022_l2034_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2022_l2034_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2035 +fn c2023_l2035_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2023_l2035_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2036 +fn c2024_l2036_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2024_l2036_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2037 +fn c2025_l2037_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2025_l2037_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2038 +fn c2026_l2038_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2026_l2038_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2039 +fn c2027_l2039_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2027_l2039_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2040 +fn c2028_l2040_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2028_l2040_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2041 +fn c2029_l2041_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2029_l2041_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2042 +fn c2030_l2042_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2030_l2042_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2043 +fn c2031_l2043_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2031_l2043_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2044 +fn c2032_l2044_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2032_l2044_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2045 +fn c2033_l2045_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2033_l2045_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2046 +fn c2034_l2046_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2034_l2046_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2047 +fn c2035_l2047_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2035_l2047_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2048 +fn c2036_l2048_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2036_l2048_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2049 +fn c2037_l2049_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2037_l2049_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2050 +fn c2038_l2050_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2038_l2050_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2051 +fn c2039_l2051_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2039_l2051_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2052 +fn c2040_l2052_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2040_l2052_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2053 +fn c2041_l2053_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2041_l2053_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2054 +fn c2042_l2054_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2042_l2054_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2055 +fn c2043_l2055_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2043_l2055_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2056 +fn c2044_l2056_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2044_l2056_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2057 +fn c2045_l2057_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2045_l2057_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2058 +fn c2046_l2058_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2046_l2058_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2059 +fn c2047_l2059_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2047_l2059_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2060 +fn c2048_l2060_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2048_l2060_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2061 +fn c2049_l2061_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2049_l2061_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2062 +fn c2050_l2062_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2050_l2062_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2063 +fn c2051_l2063_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2051_l2063_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2064 +fn c2052_l2064_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2052_l2064_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2065 +fn c2053_l2065_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2053_l2065_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2066 +fn c2054_l2066_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2054_l2066_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2067 +fn c2055_l2067_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2055_l2067_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2068 +fn c2056_l2068_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2056_l2068_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2069 +fn c2057_l2069_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2057_l2069_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2070 +fn c2058_l2070_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2058_l2070_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2071 +fn c2059_l2071_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2059_l2071_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2072 +fn c2060_l2072_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2060_l2072_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2073 +fn c2061_l2073_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2061_l2073_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2074 +fn c2062_l2074_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2062_l2074_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2075 +fn c2063_l2075_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2063_l2075_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2076 +fn c2064_l2076_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2064_l2076_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2077 +fn c2065_l2077_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2065_l2077_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2078 +fn c2066_l2078_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2066_l2078_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2079 +fn c2067_l2079_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2067_l2079_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2080 +fn c2068_l2080_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2068_l2080_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2081 +fn c2069_l2081_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2069_l2081_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2082 +fn c2070_l2082_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2070_l2082_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2083 +fn c2071_l2083_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2071_l2083_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2084 +fn c2072_l2084_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2072_l2084_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2085 +fn c2073_l2085_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2073_l2085_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2086 +fn c2074_l2086_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2074_l2086_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2087 +fn c2075_l2087_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2075_l2087_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2088 +fn c2076_l2088_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2076_l2088_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2089 +fn c2077_l2089_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2077_l2089_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2090 +fn c2078_l2090_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2078_l2090_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2091 +fn c2079_l2091_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2079_l2091_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2092 +fn c2080_l2092_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2080_l2092_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2093 +fn c2081_l2093_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2081_l2093_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2094 +fn c2082_l2094_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2082_l2094_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2095 +fn c2083_l2095_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2083_l2095_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2096 +fn c2084_l2096_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2084_l2096_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2097 +fn c2085_l2097_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2085_l2097_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2098 +fn c2086_l2098_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2086_l2098_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2099 +fn c2087_l2099_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2087_l2099_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2100 +fn c2088_l2100_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2088_l2100_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2101 +fn c2089_l2101_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2089_l2101_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2102 +fn c2090_l2102_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2090_l2102_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2103 +fn c2091_l2103_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2091_l2103_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2104 +fn c2092_l2104_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2092_l2104_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2105 +fn c2093_l2105_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2093_l2105_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2106 +fn c2094_l2106_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2094_l2106_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2107 +fn c2095_l2107_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2095_l2107_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2108 +fn c2096_l2108_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2096_l2108_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2109 +fn c2097_l2109_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2097_l2109_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2110 +fn c2098_l2110_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2098_l2110_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2111 +fn c2099_l2111_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2099_l2111_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2112 +fn c2100_l2112_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2100_l2112_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2113 +fn c2101_l2113_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2101_l2113_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2114 +fn c2102_l2114_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2102_l2114_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2115 +fn c2103_l2115_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2103_l2115_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2116 +fn c2104_l2116_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2104_l2116_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2117 +fn c2105_l2117_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2105_l2117_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2118 +fn c2106_l2118_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2106_l2118_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2119 +fn c2107_l2119_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2107_l2119_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2120 +fn c2108_l2120_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2108_l2120_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2121 +fn c2109_l2121_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2109_l2121_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2122 +fn c2110_l2122_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2110_l2122_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2123 +fn c2111_l2123_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2111_l2123_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2124 +fn c2112_l2124_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2112_l2124_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2125 +fn c2113_l2125_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2113_l2125_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2126 +fn c2114_l2126_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2114_l2126_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2127 +fn c2115_l2127_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2115_l2127_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2128 +fn c2116_l2128_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2116_l2128_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2129 +fn c2117_l2129_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2117_l2129_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2130 +fn c2118_l2130_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2118_l2130_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2131 +fn c2119_l2131_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2119_l2131_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2132 +fn c2120_l2132_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2120_l2132_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2133 +fn c2121_l2133_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2121_l2133_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2134 +fn c2122_l2134_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2122_l2134_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2135 +fn c2123_l2135_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2123_l2135_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2136 +fn c2124_l2136_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2124_l2136_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.5f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2137 +fn c2125_l2137_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2125_l2137_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2138 +fn c2126_l2138_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2126_l2138_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2139 +fn c2127_l2139_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2127_l2139_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2140 +fn c2128_l2140_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2128_l2140_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2141 +fn c2129_l2141_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2129_l2141_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2142 +fn c2130_l2142_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2130_l2142_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2143 +fn c2131_l2143_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2131_l2143_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2144 +fn c2132_l2144_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2132_l2144_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2145 +fn c2133_l2145_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2133_l2145_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2146 +fn c2134_l2146_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2134_l2146_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2147 +fn c2135_l2147_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2135_l2147_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2148 +fn c2136_l2148_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2136_l2148_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.5f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2149 +fn c2137_l2149_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2137_l2149_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.5f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2150 +fn c2138_l2150_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2138_l2150_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.5f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2151 +fn c2139_l2151_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2139_l2151_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.5f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2152 +fn c2140_l2152_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2140_l2152_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.5f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2153 +fn c2141_l2153_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2141_l2153_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.5f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2154 +fn c2142_l2154_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2142_l2154_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.5f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2155 +fn c2143_l2155_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2143_l2155_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.5f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2156 +fn c2144_l2156_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2144_l2156_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.5f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2157 +fn c2145_l2157_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2145_l2157_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.5f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2158 +fn c2146_l2158_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2146_l2158_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.5f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2159 +fn c2147_l2159_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2147_l2159_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.5f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2160 +fn c2148_l2160_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2148_l2160_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.5f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2161 +fn c2149_l2161_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2149_l2161_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2162 +fn c2150_l2162_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2150_l2162_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2163 +fn c2151_l2163_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2151_l2163_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2164 +fn c2152_l2164_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2152_l2164_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2165 +fn c2153_l2165_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2153_l2165_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2166 +fn c2154_l2166_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2154_l2166_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2167 +fn c2155_l2167_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2155_l2167_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2168 +fn c2156_l2168_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2156_l2168_action_invoke"); + let result = instance.call("ge", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2169 +fn c2157_l2169_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2157_l2169_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2170 +fn c2158_l2170_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2158_l2170_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2171 +fn c2159_l2171_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2159_l2171_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2172 +fn c2160_l2172_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2160_l2172_action_invoke"); + let result = instance.call("ge", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2173 +fn c2161_l2173_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2161_l2173_action_invoke"); + let result = instance.call("ge", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2174 +fn c2162_l2174_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2162_l2174_action_invoke"); + let result = instance.call("ge", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2175 +fn c2163_l2175_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2163_l2175_action_invoke"); + let result = instance.call("ge", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2176 +fn c2164_l2176_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2164_l2176_action_invoke"); + let result = instance.call("ge", &[Value::F32((1.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2177 +fn c2165_l2177_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2165_l2177_action_invoke"); + let result = instance.call("ge", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2178 +fn c2166_l2178_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2166_l2178_action_invoke"); + let result = instance.call("ge", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2179 +fn c2167_l2179_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2167_l2179_action_invoke"); + let result = instance.call("ge", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2180 +fn c2168_l2180_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2168_l2180_action_invoke"); + let result = instance.call("ge", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2181 +fn c2169_l2181_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2169_l2181_action_invoke"); + let result = instance.call("ge", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2182 +fn c2170_l2182_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2170_l2182_action_invoke"); + let result = instance.call("ge", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2183 +fn c2171_l2183_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2171_l2183_action_invoke"); + let result = instance.call("ge", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2184 +fn c2172_l2184_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2172_l2184_action_invoke"); + let result = instance.call("ge", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2185 +fn c2173_l2185_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2173_l2185_action_invoke"); + let result = instance.call("ge", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2186 +fn c2174_l2186_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2174_l2186_action_invoke"); + let result = instance.call("ge", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2187 +fn c2175_l2187_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2175_l2187_action_invoke"); + let result = instance.call("ge", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2188 +fn c2176_l2188_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2176_l2188_action_invoke"); + let result = instance.call("ge", &[Value::F32((1.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2189 +fn c2177_l2189_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2177_l2189_action_invoke"); + let result = instance.call("ge", &[Value::F32((-1.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2190 +fn c2178_l2190_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2178_l2190_action_invoke"); + let result = instance.call("ge", &[Value::F32((-1.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2191 +fn c2179_l2191_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2179_l2191_action_invoke"); + let result = instance.call("ge", &[Value::F32((1.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2192 +fn c2180_l2192_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2180_l2192_action_invoke"); + let result = instance.call("ge", &[Value::F32((1.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2193 +fn c2181_l2193_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2181_l2193_action_invoke"); + let result = instance.call("ge", &[Value::F32((-1.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2194 +fn c2182_l2194_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2182_l2194_action_invoke"); + let result = instance.call("ge", &[Value::F32((-1.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2195 +fn c2183_l2195_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2183_l2195_action_invoke"); + let result = instance.call("ge", &[Value::F32((1.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2196 +fn c2184_l2196_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2184_l2196_action_invoke"); + let result = instance.call("ge", &[Value::F32((1.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2197 +fn c2185_l2197_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2185_l2197_action_invoke"); + let result = instance.call("ge", &[Value::F32((-1.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2198 +fn c2186_l2198_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2186_l2198_action_invoke"); + let result = instance.call("ge", &[Value::F32((-1.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2199 +fn c2187_l2199_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2187_l2199_action_invoke"); + let result = instance.call("ge", &[Value::F32((1.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2200 +fn c2188_l2200_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2188_l2200_action_invoke"); + let result = instance.call("ge", &[Value::F32((1.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2201 +fn c2189_l2201_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2189_l2201_action_invoke"); + let result = instance.call("ge", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2202 +fn c2190_l2202_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2190_l2202_action_invoke"); + let result = instance.call("ge", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2203 +fn c2191_l2203_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2191_l2203_action_invoke"); + let result = instance.call("ge", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2204 +fn c2192_l2204_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2192_l2204_action_invoke"); + let result = instance.call("ge", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2205 +fn c2193_l2205_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2193_l2205_action_invoke"); + let result = instance.call("ge", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2206 +fn c2194_l2206_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2194_l2206_action_invoke"); + let result = instance.call("ge", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2207 +fn c2195_l2207_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2195_l2207_action_invoke"); + let result = instance.call("ge", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2208 +fn c2196_l2208_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2196_l2208_action_invoke"); + let result = instance.call("ge", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2209 +fn c2197_l2209_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2197_l2209_action_invoke"); + let result = instance.call("ge", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2210 +fn c2198_l2210_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2198_l2210_action_invoke"); + let result = instance.call("ge", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2211 +fn c2199_l2211_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2199_l2211_action_invoke"); + let result = instance.call("ge", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2212 +fn c2200_l2212_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2200_l2212_action_invoke"); + let result = instance.call("ge", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2213 +fn c2201_l2213_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2201_l2213_action_invoke"); + let result = instance.call("ge", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2214 +fn c2202_l2214_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2202_l2214_action_invoke"); + let result = instance.call("ge", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2215 +fn c2203_l2215_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2203_l2215_action_invoke"); + let result = instance.call("ge", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2216 +fn c2204_l2216_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2204_l2216_action_invoke"); + let result = instance.call("ge", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2217 +fn c2205_l2217_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2205_l2217_action_invoke"); + let result = instance.call("ge", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2218 +fn c2206_l2218_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2206_l2218_action_invoke"); + let result = instance.call("ge", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2219 +fn c2207_l2219_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2207_l2219_action_invoke"); + let result = instance.call("ge", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2220 +fn c2208_l2220_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2208_l2220_action_invoke"); + let result = instance.call("ge", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2221 +fn c2209_l2221_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2209_l2221_action_invoke"); + let result = instance.call("ge", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2222 +fn c2210_l2222_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2210_l2222_action_invoke"); + let result = instance.call("ge", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2223 +fn c2211_l2223_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2211_l2223_action_invoke"); + let result = instance.call("ge", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2224 +fn c2212_l2224_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2212_l2224_action_invoke"); + let result = instance.call("ge", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2225 +fn c2213_l2225_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2213_l2225_action_invoke"); + let result = instance.call("ge", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2226 +fn c2214_l2226_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2214_l2226_action_invoke"); + let result = instance.call("ge", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2227 +fn c2215_l2227_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2215_l2227_action_invoke"); + let result = instance.call("ge", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2228 +fn c2216_l2228_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2216_l2228_action_invoke"); + let result = instance.call("ge", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2229 +fn c2217_l2229_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2217_l2229_action_invoke"); + let result = instance.call("ge", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2230 +fn c2218_l2230_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2218_l2230_action_invoke"); + let result = instance.call("ge", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2231 +fn c2219_l2231_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2219_l2231_action_invoke"); + let result = instance.call("ge", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2232 +fn c2220_l2232_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2220_l2232_action_invoke"); + let result = instance.call("ge", &[Value::F32((6.2831855f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2233 +fn c2221_l2233_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2221_l2233_action_invoke"); + let result = instance.call("ge", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2234 +fn c2222_l2234_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2222_l2234_action_invoke"); + let result = instance.call("ge", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2235 +fn c2223_l2235_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2223_l2235_action_invoke"); + let result = instance.call("ge", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2236 +fn c2224_l2236_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2224_l2236_action_invoke"); + let result = instance.call("ge", &[Value::F32((6.2831855f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2237 +fn c2225_l2237_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2225_l2237_action_invoke"); + let result = instance.call("ge", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2238 +fn c2226_l2238_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2226_l2238_action_invoke"); + let result = instance.call("ge", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2239 +fn c2227_l2239_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2227_l2239_action_invoke"); + let result = instance.call("ge", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2240 +fn c2228_l2240_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2228_l2240_action_invoke"); + let result = instance.call("ge", &[Value::F32((6.2831855f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2241 +fn c2229_l2241_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2229_l2241_action_invoke"); + let result = instance.call("ge", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2242 +fn c2230_l2242_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2230_l2242_action_invoke"); + let result = instance.call("ge", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2243 +fn c2231_l2243_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2231_l2243_action_invoke"); + let result = instance.call("ge", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2244 +fn c2232_l2244_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2232_l2244_action_invoke"); + let result = instance.call("ge", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2245 +fn c2233_l2245_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2233_l2245_action_invoke"); + let result = instance.call("ge", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2246 +fn c2234_l2246_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2234_l2246_action_invoke"); + let result = instance.call("ge", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2247 +fn c2235_l2247_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2235_l2247_action_invoke"); + let result = instance.call("ge", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2248 +fn c2236_l2248_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2236_l2248_action_invoke"); + let result = instance.call("ge", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2249 +fn c2237_l2249_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2237_l2249_action_invoke"); + let result = instance.call("ge", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2250 +fn c2238_l2250_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2238_l2250_action_invoke"); + let result = instance.call("ge", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2251 +fn c2239_l2251_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2239_l2251_action_invoke"); + let result = instance.call("ge", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2252 +fn c2240_l2252_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2240_l2252_action_invoke"); + let result = instance.call("ge", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2253 +fn c2241_l2253_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2241_l2253_action_invoke"); + let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2254 +fn c2242_l2254_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2242_l2254_action_invoke"); + let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2255 +fn c2243_l2255_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2243_l2255_action_invoke"); + let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2256 +fn c2244_l2256_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2244_l2256_action_invoke"); + let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2257 +fn c2245_l2257_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2245_l2257_action_invoke"); + let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2258 +fn c2246_l2258_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2246_l2258_action_invoke"); + let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2259 +fn c2247_l2259_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2247_l2259_action_invoke"); + let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2260 +fn c2248_l2260_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2248_l2260_action_invoke"); + let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2261 +fn c2249_l2261_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2249_l2261_action_invoke"); + let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2262 +fn c2250_l2262_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2250_l2262_action_invoke"); + let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2263 +fn c2251_l2263_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2251_l2263_action_invoke"); + let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2264 +fn c2252_l2264_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2252_l2264_action_invoke"); + let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2265 +fn c2253_l2265_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2253_l2265_action_invoke"); + let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2266 +fn c2254_l2266_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2254_l2266_action_invoke"); + let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2267 +fn c2255_l2267_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2255_l2267_action_invoke"); + let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2268 +fn c2256_l2268_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2256_l2268_action_invoke"); + let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2269 +fn c2257_l2269_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2257_l2269_action_invoke"); + let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2270 +fn c2258_l2270_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2258_l2270_action_invoke"); + let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2271 +fn c2259_l2271_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2259_l2271_action_invoke"); + let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2272 +fn c2260_l2272_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2260_l2272_action_invoke"); + let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2273 +fn c2261_l2273_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2261_l2273_action_invoke"); + let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2274 +fn c2262_l2274_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2262_l2274_action_invoke"); + let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2275 +fn c2263_l2275_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2263_l2275_action_invoke"); + let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2276 +fn c2264_l2276_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2264_l2276_action_invoke"); + let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2277 +fn c2265_l2277_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2265_l2277_action_invoke"); + let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2278 +fn c2266_l2278_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2266_l2278_action_invoke"); + let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2279 +fn c2267_l2279_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2267_l2279_action_invoke"); + let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2280 +fn c2268_l2280_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2268_l2280_action_invoke"); + let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2281 +fn c2269_l2281_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2269_l2281_action_invoke"); + let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2282 +fn c2270_l2282_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2270_l2282_action_invoke"); + let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2283 +fn c2271_l2283_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2271_l2283_action_invoke"); + let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2284 +fn c2272_l2284_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2272_l2284_action_invoke"); + let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2285 +fn c2273_l2285_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2273_l2285_action_invoke"); + let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2286 +fn c2274_l2286_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2274_l2286_action_invoke"); + let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2287 +fn c2275_l2287_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2275_l2287_action_invoke"); + let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2288 +fn c2276_l2288_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2276_l2288_action_invoke"); + let result = instance.call("ge", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2289 +fn c2277_l2289_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2277_l2289_action_invoke"); + let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2290 +fn c2278_l2290_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2278_l2290_action_invoke"); + let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2291 +fn c2279_l2291_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2279_l2291_action_invoke"); + let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2292 +fn c2280_l2292_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2280_l2292_action_invoke"); + let result = instance.call("ge", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2293 +fn c2281_l2293_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2281_l2293_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2294 +fn c2282_l2294_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2282_l2294_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2295 +fn c2283_l2295_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2283_l2295_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2296 +fn c2284_l2296_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2284_l2296_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2297 +fn c2285_l2297_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2285_l2297_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2298 +fn c2286_l2298_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2286_l2298_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2299 +fn c2287_l2299_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2287_l2299_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2300 +fn c2288_l2300_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2288_l2300_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2301 +fn c2289_l2301_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2289_l2301_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2302 +fn c2290_l2302_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2290_l2302_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2303 +fn c2291_l2303_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2291_l2303_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2304 +fn c2292_l2304_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2292_l2304_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2305 +fn c2293_l2305_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2293_l2305_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2306 +fn c2294_l2306_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2294_l2306_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2307 +fn c2295_l2307_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2295_l2307_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2308 +fn c2296_l2308_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2296_l2308_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2309 +fn c2297_l2309_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2297_l2309_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2310 +fn c2298_l2310_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2298_l2310_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2311 +fn c2299_l2311_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2299_l2311_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2312 +fn c2300_l2312_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2300_l2312_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2313 +fn c2301_l2313_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2301_l2313_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2314 +fn c2302_l2314_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2302_l2314_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2315 +fn c2303_l2315_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2303_l2315_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2316 +fn c2304_l2316_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2304_l2316_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2317 +fn c2305_l2317_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2305_l2317_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2318 +fn c2306_l2318_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2306_l2318_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2319 +fn c2307_l2319_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2307_l2319_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2320 +fn c2308_l2320_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2308_l2320_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2321 +fn c2309_l2321_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2309_l2321_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2322 +fn c2310_l2322_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2310_l2322_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2323 +fn c2311_l2323_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2311_l2323_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2324 +fn c2312_l2324_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2312_l2324_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2325 +fn c2313_l2325_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2313_l2325_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2326 +fn c2314_l2326_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2314_l2326_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2327 +fn c2315_l2327_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2315_l2327_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2328 +fn c2316_l2328_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2316_l2328_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2329 +fn c2317_l2329_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2317_l2329_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2330 +fn c2318_l2330_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2318_l2330_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2331 +fn c2319_l2331_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2319_l2331_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2332 +fn c2320_l2332_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2320_l2332_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2333 +fn c2321_l2333_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2321_l2333_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2334 +fn c2322_l2334_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2322_l2334_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2335 +fn c2323_l2335_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2323_l2335_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2336 +fn c2324_l2336_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2324_l2336_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2337 +fn c2325_l2337_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2325_l2337_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2338 +fn c2326_l2338_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2326_l2338_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2339 +fn c2327_l2339_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2327_l2339_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2340 +fn c2328_l2340_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2328_l2340_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2341 +fn c2329_l2341_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2329_l2341_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2342 +fn c2330_l2342_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2330_l2342_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2343 +fn c2331_l2343_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2331_l2343_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2344 +fn c2332_l2344_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2332_l2344_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2345 +fn c2333_l2345_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2333_l2345_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2346 +fn c2334_l2346_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2334_l2346_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2347 +fn c2335_l2347_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2335_l2347_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2348 +fn c2336_l2348_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2336_l2348_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2349 +fn c2337_l2349_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2337_l2349_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2350 +fn c2338_l2350_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2338_l2350_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2351 +fn c2339_l2351_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2339_l2351_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2352 +fn c2340_l2352_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2340_l2352_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2353 +fn c2341_l2353_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2341_l2353_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2354 +fn c2342_l2354_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2342_l2354_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2355 +fn c2343_l2355_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2343_l2355_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2356 +fn c2344_l2356_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2344_l2356_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2357 +fn c2345_l2357_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2345_l2357_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2358 +fn c2346_l2358_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2346_l2358_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2359 +fn c2347_l2359_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2347_l2359_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2360 +fn c2348_l2360_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2348_l2360_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2361 +fn c2349_l2361_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2349_l2361_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2362 +fn c2350_l2362_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2350_l2362_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2363 +fn c2351_l2363_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2351_l2363_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2364 +fn c2352_l2364_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2352_l2364_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2365 +fn c2353_l2365_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2353_l2365_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2366 +fn c2354_l2366_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2354_l2366_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2367 +fn c2355_l2367_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2355_l2367_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2368 +fn c2356_l2368_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2356_l2368_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2369 +fn c2357_l2369_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2357_l2369_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2370 +fn c2358_l2370_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2358_l2370_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2371 +fn c2359_l2371_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2359_l2371_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2372 +fn c2360_l2372_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2360_l2372_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2373 +fn c2361_l2373_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2361_l2373_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2374 +fn c2362_l2374_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2362_l2374_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2375 +fn c2363_l2375_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2363_l2375_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2376 +fn c2364_l2376_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2364_l2376_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2377 +fn c2365_l2377_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2365_l2377_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2378 +fn c2366_l2378_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2366_l2378_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2379 +fn c2367_l2379_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2367_l2379_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2380 +fn c2368_l2380_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2368_l2380_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((6.2831855f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2381 +fn c2369_l2381_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2369_l2381_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2382 +fn c2370_l2382_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2370_l2382_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2383 +fn c2371_l2383_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2371_l2383_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2384 +fn c2372_l2384_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2372_l2384_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2385 +fn c2373_l2385_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2373_l2385_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2386 +fn c2374_l2386_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2374_l2386_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2387 +fn c2375_l2387_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2375_l2387_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2388 +fn c2376_l2388_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2376_l2388_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2389 +fn c2377_l2389_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2377_l2389_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2390 +fn c2378_l2390_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2378_l2390_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2391 +fn c2379_l2391_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2379_l2391_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2392 +fn c2380_l2392_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2380_l2392_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2393 +fn c2381_l2393_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2381_l2393_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2394 +fn c2382_l2394_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2382_l2394_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2395 +fn c2383_l2395_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2383_l2395_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2396 +fn c2384_l2396_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2384_l2396_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2397 +fn c2385_l2397_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2385_l2397_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2398 +fn c2386_l2398_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2386_l2398_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2399 +fn c2387_l2399_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2387_l2399_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2400 +fn c2388_l2400_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2388_l2400_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2401 +fn c2389_l2401_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2389_l2401_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2402 +fn c2390_l2402_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2390_l2402_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2403 +fn c2391_l2403_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2391_l2403_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2404 +fn c2392_l2404_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2392_l2404_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(4288675840) as u32), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2405 +fn c2393_l2405_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2393_l2405_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2406 +fn c2394_l2406_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2394_l2406_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(4290772992) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2407 +fn c2395_l2407_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2395_l2407_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2408 +fn c2396_l2408_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2396_l2408_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(4288675840) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2409 +fn c2397_l2409_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2397_l2409_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2410 +fn c2398_l2410_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2398_l2410_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2411 +fn c2399_l2411_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2399_l2411_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2412 +fn c2400_l2412_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2400_l2412_action_invoke"); + let result = instance.call("ge", &[Value::F32(f32::from_bits(2141192192) as u32), Value::F32(f32::from_bits(2141192192) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l13_action_invoke(&mut instance); + c2_l14_action_invoke(&mut instance); + c3_l15_action_invoke(&mut instance); + c4_l16_action_invoke(&mut instance); + c5_l17_action_invoke(&mut instance); + c6_l18_action_invoke(&mut instance); + c7_l19_action_invoke(&mut instance); + c8_l20_action_invoke(&mut instance); + c9_l21_action_invoke(&mut instance); + c10_l22_action_invoke(&mut instance); + c11_l23_action_invoke(&mut instance); + c12_l24_action_invoke(&mut instance); + c13_l25_action_invoke(&mut instance); + c14_l26_action_invoke(&mut instance); + c15_l27_action_invoke(&mut instance); + c16_l28_action_invoke(&mut instance); + c17_l29_action_invoke(&mut instance); + c18_l30_action_invoke(&mut instance); + c19_l31_action_invoke(&mut instance); + c20_l32_action_invoke(&mut instance); + c21_l33_action_invoke(&mut instance); + c22_l34_action_invoke(&mut instance); + c23_l35_action_invoke(&mut instance); + c24_l36_action_invoke(&mut instance); + c25_l37_action_invoke(&mut instance); + c26_l38_action_invoke(&mut instance); + c27_l39_action_invoke(&mut instance); + c28_l40_action_invoke(&mut instance); + c29_l41_action_invoke(&mut instance); + c30_l42_action_invoke(&mut instance); + c31_l43_action_invoke(&mut instance); + c32_l44_action_invoke(&mut instance); + c33_l45_action_invoke(&mut instance); + c34_l46_action_invoke(&mut instance); + c35_l47_action_invoke(&mut instance); + c36_l48_action_invoke(&mut instance); + c37_l49_action_invoke(&mut instance); + c38_l50_action_invoke(&mut instance); + c39_l51_action_invoke(&mut instance); + c40_l52_action_invoke(&mut instance); + c41_l53_action_invoke(&mut instance); + c42_l54_action_invoke(&mut instance); + c43_l55_action_invoke(&mut instance); + c44_l56_action_invoke(&mut instance); + c45_l57_action_invoke(&mut instance); + c46_l58_action_invoke(&mut instance); + c47_l59_action_invoke(&mut instance); + c48_l60_action_invoke(&mut instance); + c49_l61_action_invoke(&mut instance); + c50_l62_action_invoke(&mut instance); + c51_l63_action_invoke(&mut instance); + c52_l64_action_invoke(&mut instance); + c53_l65_action_invoke(&mut instance); + c54_l66_action_invoke(&mut instance); + c55_l67_action_invoke(&mut instance); + c56_l68_action_invoke(&mut instance); + c57_l69_action_invoke(&mut instance); + c58_l70_action_invoke(&mut instance); + c59_l71_action_invoke(&mut instance); + c60_l72_action_invoke(&mut instance); + c61_l73_action_invoke(&mut instance); + c62_l74_action_invoke(&mut instance); + c63_l75_action_invoke(&mut instance); + c64_l76_action_invoke(&mut instance); + c65_l77_action_invoke(&mut instance); + c66_l78_action_invoke(&mut instance); + c67_l79_action_invoke(&mut instance); + c68_l80_action_invoke(&mut instance); + c69_l81_action_invoke(&mut instance); + c70_l82_action_invoke(&mut instance); + c71_l83_action_invoke(&mut instance); + c72_l84_action_invoke(&mut instance); + c73_l85_action_invoke(&mut instance); + c74_l86_action_invoke(&mut instance); + c75_l87_action_invoke(&mut instance); + c76_l88_action_invoke(&mut instance); + c77_l89_action_invoke(&mut instance); + c78_l90_action_invoke(&mut instance); + c79_l91_action_invoke(&mut instance); + c80_l92_action_invoke(&mut instance); + c81_l93_action_invoke(&mut instance); + c82_l94_action_invoke(&mut instance); + c83_l95_action_invoke(&mut instance); + c84_l96_action_invoke(&mut instance); + c85_l97_action_invoke(&mut instance); + c86_l98_action_invoke(&mut instance); + c87_l99_action_invoke(&mut instance); + c88_l100_action_invoke(&mut instance); + c89_l101_action_invoke(&mut instance); + c90_l102_action_invoke(&mut instance); + c91_l103_action_invoke(&mut instance); + c92_l104_action_invoke(&mut instance); + c93_l105_action_invoke(&mut instance); + c94_l106_action_invoke(&mut instance); + c95_l107_action_invoke(&mut instance); + c96_l108_action_invoke(&mut instance); + c97_l109_action_invoke(&mut instance); + c98_l110_action_invoke(&mut instance); + c99_l111_action_invoke(&mut instance); + c100_l112_action_invoke(&mut instance); + c101_l113_action_invoke(&mut instance); + c102_l114_action_invoke(&mut instance); + c103_l115_action_invoke(&mut instance); + c104_l116_action_invoke(&mut instance); + c105_l117_action_invoke(&mut instance); + c106_l118_action_invoke(&mut instance); + c107_l119_action_invoke(&mut instance); + c108_l120_action_invoke(&mut instance); + c109_l121_action_invoke(&mut instance); + c110_l122_action_invoke(&mut instance); + c111_l123_action_invoke(&mut instance); + c112_l124_action_invoke(&mut instance); + c113_l125_action_invoke(&mut instance); + c114_l126_action_invoke(&mut instance); + c115_l127_action_invoke(&mut instance); + c116_l128_action_invoke(&mut instance); + c117_l129_action_invoke(&mut instance); + c118_l130_action_invoke(&mut instance); + c119_l131_action_invoke(&mut instance); + c120_l132_action_invoke(&mut instance); + c121_l133_action_invoke(&mut instance); + c122_l134_action_invoke(&mut instance); + c123_l135_action_invoke(&mut instance); + c124_l136_action_invoke(&mut instance); + c125_l137_action_invoke(&mut instance); + c126_l138_action_invoke(&mut instance); + c127_l139_action_invoke(&mut instance); + c128_l140_action_invoke(&mut instance); + c129_l141_action_invoke(&mut instance); + c130_l142_action_invoke(&mut instance); + c131_l143_action_invoke(&mut instance); + c132_l144_action_invoke(&mut instance); + c133_l145_action_invoke(&mut instance); + c134_l146_action_invoke(&mut instance); + c135_l147_action_invoke(&mut instance); + c136_l148_action_invoke(&mut instance); + c137_l149_action_invoke(&mut instance); + c138_l150_action_invoke(&mut instance); + c139_l151_action_invoke(&mut instance); + c140_l152_action_invoke(&mut instance); + c141_l153_action_invoke(&mut instance); + c142_l154_action_invoke(&mut instance); + c143_l155_action_invoke(&mut instance); + c144_l156_action_invoke(&mut instance); + c145_l157_action_invoke(&mut instance); + c146_l158_action_invoke(&mut instance); + c147_l159_action_invoke(&mut instance); + c148_l160_action_invoke(&mut instance); + c149_l161_action_invoke(&mut instance); + c150_l162_action_invoke(&mut instance); + c151_l163_action_invoke(&mut instance); + c152_l164_action_invoke(&mut instance); + c153_l165_action_invoke(&mut instance); + c154_l166_action_invoke(&mut instance); + c155_l167_action_invoke(&mut instance); + c156_l168_action_invoke(&mut instance); + c157_l169_action_invoke(&mut instance); + c158_l170_action_invoke(&mut instance); + c159_l171_action_invoke(&mut instance); + c160_l172_action_invoke(&mut instance); + c161_l173_action_invoke(&mut instance); + c162_l174_action_invoke(&mut instance); + c163_l175_action_invoke(&mut instance); + c164_l176_action_invoke(&mut instance); + c165_l177_action_invoke(&mut instance); + c166_l178_action_invoke(&mut instance); + c167_l179_action_invoke(&mut instance); + c168_l180_action_invoke(&mut instance); + c169_l181_action_invoke(&mut instance); + c170_l182_action_invoke(&mut instance); + c171_l183_action_invoke(&mut instance); + c172_l184_action_invoke(&mut instance); + c173_l185_action_invoke(&mut instance); + c174_l186_action_invoke(&mut instance); + c175_l187_action_invoke(&mut instance); + c176_l188_action_invoke(&mut instance); + c177_l189_action_invoke(&mut instance); + c178_l190_action_invoke(&mut instance); + c179_l191_action_invoke(&mut instance); + c180_l192_action_invoke(&mut instance); + c181_l193_action_invoke(&mut instance); + c182_l194_action_invoke(&mut instance); + c183_l195_action_invoke(&mut instance); + c184_l196_action_invoke(&mut instance); + c185_l197_action_invoke(&mut instance); + c186_l198_action_invoke(&mut instance); + c187_l199_action_invoke(&mut instance); + c188_l200_action_invoke(&mut instance); + c189_l201_action_invoke(&mut instance); + c190_l202_action_invoke(&mut instance); + c191_l203_action_invoke(&mut instance); + c192_l204_action_invoke(&mut instance); + c193_l205_action_invoke(&mut instance); + c194_l206_action_invoke(&mut instance); + c195_l207_action_invoke(&mut instance); + c196_l208_action_invoke(&mut instance); + c197_l209_action_invoke(&mut instance); + c198_l210_action_invoke(&mut instance); + c199_l211_action_invoke(&mut instance); + c200_l212_action_invoke(&mut instance); + c201_l213_action_invoke(&mut instance); + c202_l214_action_invoke(&mut instance); + c203_l215_action_invoke(&mut instance); + c204_l216_action_invoke(&mut instance); + c205_l217_action_invoke(&mut instance); + c206_l218_action_invoke(&mut instance); + c207_l219_action_invoke(&mut instance); + c208_l220_action_invoke(&mut instance); + c209_l221_action_invoke(&mut instance); + c210_l222_action_invoke(&mut instance); + c211_l223_action_invoke(&mut instance); + c212_l224_action_invoke(&mut instance); + c213_l225_action_invoke(&mut instance); + c214_l226_action_invoke(&mut instance); + c215_l227_action_invoke(&mut instance); + c216_l228_action_invoke(&mut instance); + c217_l229_action_invoke(&mut instance); + c218_l230_action_invoke(&mut instance); + c219_l231_action_invoke(&mut instance); + c220_l232_action_invoke(&mut instance); + c221_l233_action_invoke(&mut instance); + c222_l234_action_invoke(&mut instance); + c223_l235_action_invoke(&mut instance); + c224_l236_action_invoke(&mut instance); + c225_l237_action_invoke(&mut instance); + c226_l238_action_invoke(&mut instance); + c227_l239_action_invoke(&mut instance); + c228_l240_action_invoke(&mut instance); + c229_l241_action_invoke(&mut instance); + c230_l242_action_invoke(&mut instance); + c231_l243_action_invoke(&mut instance); + c232_l244_action_invoke(&mut instance); + c233_l245_action_invoke(&mut instance); + c234_l246_action_invoke(&mut instance); + c235_l247_action_invoke(&mut instance); + c236_l248_action_invoke(&mut instance); + c237_l249_action_invoke(&mut instance); + c238_l250_action_invoke(&mut instance); + c239_l251_action_invoke(&mut instance); + c240_l252_action_invoke(&mut instance); + c241_l253_action_invoke(&mut instance); + c242_l254_action_invoke(&mut instance); + c243_l255_action_invoke(&mut instance); + c244_l256_action_invoke(&mut instance); + c245_l257_action_invoke(&mut instance); + c246_l258_action_invoke(&mut instance); + c247_l259_action_invoke(&mut instance); + c248_l260_action_invoke(&mut instance); + c249_l261_action_invoke(&mut instance); + c250_l262_action_invoke(&mut instance); + c251_l263_action_invoke(&mut instance); + c252_l264_action_invoke(&mut instance); + c253_l265_action_invoke(&mut instance); + c254_l266_action_invoke(&mut instance); + c255_l267_action_invoke(&mut instance); + c256_l268_action_invoke(&mut instance); + c257_l269_action_invoke(&mut instance); + c258_l270_action_invoke(&mut instance); + c259_l271_action_invoke(&mut instance); + c260_l272_action_invoke(&mut instance); + c261_l273_action_invoke(&mut instance); + c262_l274_action_invoke(&mut instance); + c263_l275_action_invoke(&mut instance); + c264_l276_action_invoke(&mut instance); + c265_l277_action_invoke(&mut instance); + c266_l278_action_invoke(&mut instance); + c267_l279_action_invoke(&mut instance); + c268_l280_action_invoke(&mut instance); + c269_l281_action_invoke(&mut instance); + c270_l282_action_invoke(&mut instance); + c271_l283_action_invoke(&mut instance); + c272_l284_action_invoke(&mut instance); + c273_l285_action_invoke(&mut instance); + c274_l286_action_invoke(&mut instance); + c275_l287_action_invoke(&mut instance); + c276_l288_action_invoke(&mut instance); + c277_l289_action_invoke(&mut instance); + c278_l290_action_invoke(&mut instance); + c279_l291_action_invoke(&mut instance); + c280_l292_action_invoke(&mut instance); + c281_l293_action_invoke(&mut instance); + c282_l294_action_invoke(&mut instance); + c283_l295_action_invoke(&mut instance); + c284_l296_action_invoke(&mut instance); + c285_l297_action_invoke(&mut instance); + c286_l298_action_invoke(&mut instance); + c287_l299_action_invoke(&mut instance); + c288_l300_action_invoke(&mut instance); + c289_l301_action_invoke(&mut instance); + c290_l302_action_invoke(&mut instance); + c291_l303_action_invoke(&mut instance); + c292_l304_action_invoke(&mut instance); + c293_l305_action_invoke(&mut instance); + c294_l306_action_invoke(&mut instance); + c295_l307_action_invoke(&mut instance); + c296_l308_action_invoke(&mut instance); + c297_l309_action_invoke(&mut instance); + c298_l310_action_invoke(&mut instance); + c299_l311_action_invoke(&mut instance); + c300_l312_action_invoke(&mut instance); + c301_l313_action_invoke(&mut instance); + c302_l314_action_invoke(&mut instance); + c303_l315_action_invoke(&mut instance); + c304_l316_action_invoke(&mut instance); + c305_l317_action_invoke(&mut instance); + c306_l318_action_invoke(&mut instance); + c307_l319_action_invoke(&mut instance); + c308_l320_action_invoke(&mut instance); + c309_l321_action_invoke(&mut instance); + c310_l322_action_invoke(&mut instance); + c311_l323_action_invoke(&mut instance); + c312_l324_action_invoke(&mut instance); + c313_l325_action_invoke(&mut instance); + c314_l326_action_invoke(&mut instance); + c315_l327_action_invoke(&mut instance); + c316_l328_action_invoke(&mut instance); + c317_l329_action_invoke(&mut instance); + c318_l330_action_invoke(&mut instance); + c319_l331_action_invoke(&mut instance); + c320_l332_action_invoke(&mut instance); + c321_l333_action_invoke(&mut instance); + c322_l334_action_invoke(&mut instance); + c323_l335_action_invoke(&mut instance); + c324_l336_action_invoke(&mut instance); + c325_l337_action_invoke(&mut instance); + c326_l338_action_invoke(&mut instance); + c327_l339_action_invoke(&mut instance); + c328_l340_action_invoke(&mut instance); + c329_l341_action_invoke(&mut instance); + c330_l342_action_invoke(&mut instance); + c331_l343_action_invoke(&mut instance); + c332_l344_action_invoke(&mut instance); + c333_l345_action_invoke(&mut instance); + c334_l346_action_invoke(&mut instance); + c335_l347_action_invoke(&mut instance); + c336_l348_action_invoke(&mut instance); + c337_l349_action_invoke(&mut instance); + c338_l350_action_invoke(&mut instance); + c339_l351_action_invoke(&mut instance); + c340_l352_action_invoke(&mut instance); + c341_l353_action_invoke(&mut instance); + c342_l354_action_invoke(&mut instance); + c343_l355_action_invoke(&mut instance); + c344_l356_action_invoke(&mut instance); + c345_l357_action_invoke(&mut instance); + c346_l358_action_invoke(&mut instance); + c347_l359_action_invoke(&mut instance); + c348_l360_action_invoke(&mut instance); + c349_l361_action_invoke(&mut instance); + c350_l362_action_invoke(&mut instance); + c351_l363_action_invoke(&mut instance); + c352_l364_action_invoke(&mut instance); + c353_l365_action_invoke(&mut instance); + c354_l366_action_invoke(&mut instance); + c355_l367_action_invoke(&mut instance); + c356_l368_action_invoke(&mut instance); + c357_l369_action_invoke(&mut instance); + c358_l370_action_invoke(&mut instance); + c359_l371_action_invoke(&mut instance); + c360_l372_action_invoke(&mut instance); + c361_l373_action_invoke(&mut instance); + c362_l374_action_invoke(&mut instance); + c363_l375_action_invoke(&mut instance); + c364_l376_action_invoke(&mut instance); + c365_l377_action_invoke(&mut instance); + c366_l378_action_invoke(&mut instance); + c367_l379_action_invoke(&mut instance); + c368_l380_action_invoke(&mut instance); + c369_l381_action_invoke(&mut instance); + c370_l382_action_invoke(&mut instance); + c371_l383_action_invoke(&mut instance); + c372_l384_action_invoke(&mut instance); + c373_l385_action_invoke(&mut instance); + c374_l386_action_invoke(&mut instance); + c375_l387_action_invoke(&mut instance); + c376_l388_action_invoke(&mut instance); + c377_l389_action_invoke(&mut instance); + c378_l390_action_invoke(&mut instance); + c379_l391_action_invoke(&mut instance); + c380_l392_action_invoke(&mut instance); + c381_l393_action_invoke(&mut instance); + c382_l394_action_invoke(&mut instance); + c383_l395_action_invoke(&mut instance); + c384_l396_action_invoke(&mut instance); + c385_l397_action_invoke(&mut instance); + c386_l398_action_invoke(&mut instance); + c387_l399_action_invoke(&mut instance); + c388_l400_action_invoke(&mut instance); + c389_l401_action_invoke(&mut instance); + c390_l402_action_invoke(&mut instance); + c391_l403_action_invoke(&mut instance); + c392_l404_action_invoke(&mut instance); + c393_l405_action_invoke(&mut instance); + c394_l406_action_invoke(&mut instance); + c395_l407_action_invoke(&mut instance); + c396_l408_action_invoke(&mut instance); + c397_l409_action_invoke(&mut instance); + c398_l410_action_invoke(&mut instance); + c399_l411_action_invoke(&mut instance); + c400_l412_action_invoke(&mut instance); + c401_l413_action_invoke(&mut instance); + c402_l414_action_invoke(&mut instance); + c403_l415_action_invoke(&mut instance); + c404_l416_action_invoke(&mut instance); + c405_l417_action_invoke(&mut instance); + c406_l418_action_invoke(&mut instance); + c407_l419_action_invoke(&mut instance); + c408_l420_action_invoke(&mut instance); + c409_l421_action_invoke(&mut instance); + c410_l422_action_invoke(&mut instance); + c411_l423_action_invoke(&mut instance); + c412_l424_action_invoke(&mut instance); + c413_l425_action_invoke(&mut instance); + c414_l426_action_invoke(&mut instance); + c415_l427_action_invoke(&mut instance); + c416_l428_action_invoke(&mut instance); + c417_l429_action_invoke(&mut instance); + c418_l430_action_invoke(&mut instance); + c419_l431_action_invoke(&mut instance); + c420_l432_action_invoke(&mut instance); + c421_l433_action_invoke(&mut instance); + c422_l434_action_invoke(&mut instance); + c423_l435_action_invoke(&mut instance); + c424_l436_action_invoke(&mut instance); + c425_l437_action_invoke(&mut instance); + c426_l438_action_invoke(&mut instance); + c427_l439_action_invoke(&mut instance); + c428_l440_action_invoke(&mut instance); + c429_l441_action_invoke(&mut instance); + c430_l442_action_invoke(&mut instance); + c431_l443_action_invoke(&mut instance); + c432_l444_action_invoke(&mut instance); + c433_l445_action_invoke(&mut instance); + c434_l446_action_invoke(&mut instance); + c435_l447_action_invoke(&mut instance); + c436_l448_action_invoke(&mut instance); + c437_l449_action_invoke(&mut instance); + c438_l450_action_invoke(&mut instance); + c439_l451_action_invoke(&mut instance); + c440_l452_action_invoke(&mut instance); + c441_l453_action_invoke(&mut instance); + c442_l454_action_invoke(&mut instance); + c443_l455_action_invoke(&mut instance); + c444_l456_action_invoke(&mut instance); + c445_l457_action_invoke(&mut instance); + c446_l458_action_invoke(&mut instance); + c447_l459_action_invoke(&mut instance); + c448_l460_action_invoke(&mut instance); + c449_l461_action_invoke(&mut instance); + c450_l462_action_invoke(&mut instance); + c451_l463_action_invoke(&mut instance); + c452_l464_action_invoke(&mut instance); + c453_l465_action_invoke(&mut instance); + c454_l466_action_invoke(&mut instance); + c455_l467_action_invoke(&mut instance); + c456_l468_action_invoke(&mut instance); + c457_l469_action_invoke(&mut instance); + c458_l470_action_invoke(&mut instance); + c459_l471_action_invoke(&mut instance); + c460_l472_action_invoke(&mut instance); + c461_l473_action_invoke(&mut instance); + c462_l474_action_invoke(&mut instance); + c463_l475_action_invoke(&mut instance); + c464_l476_action_invoke(&mut instance); + c465_l477_action_invoke(&mut instance); + c466_l478_action_invoke(&mut instance); + c467_l479_action_invoke(&mut instance); + c468_l480_action_invoke(&mut instance); + c469_l481_action_invoke(&mut instance); + c470_l482_action_invoke(&mut instance); + c471_l483_action_invoke(&mut instance); + c472_l484_action_invoke(&mut instance); + c473_l485_action_invoke(&mut instance); + c474_l486_action_invoke(&mut instance); + c475_l487_action_invoke(&mut instance); + c476_l488_action_invoke(&mut instance); + c477_l489_action_invoke(&mut instance); + c478_l490_action_invoke(&mut instance); + c479_l491_action_invoke(&mut instance); + c480_l492_action_invoke(&mut instance); + c481_l493_action_invoke(&mut instance); + c482_l494_action_invoke(&mut instance); + c483_l495_action_invoke(&mut instance); + c484_l496_action_invoke(&mut instance); + c485_l497_action_invoke(&mut instance); + c486_l498_action_invoke(&mut instance); + c487_l499_action_invoke(&mut instance); + c488_l500_action_invoke(&mut instance); + c489_l501_action_invoke(&mut instance); + c490_l502_action_invoke(&mut instance); + c491_l503_action_invoke(&mut instance); + c492_l504_action_invoke(&mut instance); + c493_l505_action_invoke(&mut instance); + c494_l506_action_invoke(&mut instance); + c495_l507_action_invoke(&mut instance); + c496_l508_action_invoke(&mut instance); + c497_l509_action_invoke(&mut instance); + c498_l510_action_invoke(&mut instance); + c499_l511_action_invoke(&mut instance); + c500_l512_action_invoke(&mut instance); + c501_l513_action_invoke(&mut instance); + c502_l514_action_invoke(&mut instance); + c503_l515_action_invoke(&mut instance); + c504_l516_action_invoke(&mut instance); + c505_l517_action_invoke(&mut instance); + c506_l518_action_invoke(&mut instance); + c507_l519_action_invoke(&mut instance); + c508_l520_action_invoke(&mut instance); + c509_l521_action_invoke(&mut instance); + c510_l522_action_invoke(&mut instance); + c511_l523_action_invoke(&mut instance); + c512_l524_action_invoke(&mut instance); + c513_l525_action_invoke(&mut instance); + c514_l526_action_invoke(&mut instance); + c515_l527_action_invoke(&mut instance); + c516_l528_action_invoke(&mut instance); + c517_l529_action_invoke(&mut instance); + c518_l530_action_invoke(&mut instance); + c519_l531_action_invoke(&mut instance); + c520_l532_action_invoke(&mut instance); + c521_l533_action_invoke(&mut instance); + c522_l534_action_invoke(&mut instance); + c523_l535_action_invoke(&mut instance); + c524_l536_action_invoke(&mut instance); + c525_l537_action_invoke(&mut instance); + c526_l538_action_invoke(&mut instance); + c527_l539_action_invoke(&mut instance); + c528_l540_action_invoke(&mut instance); + c529_l541_action_invoke(&mut instance); + c530_l542_action_invoke(&mut instance); + c531_l543_action_invoke(&mut instance); + c532_l544_action_invoke(&mut instance); + c533_l545_action_invoke(&mut instance); + c534_l546_action_invoke(&mut instance); + c535_l547_action_invoke(&mut instance); + c536_l548_action_invoke(&mut instance); + c537_l549_action_invoke(&mut instance); + c538_l550_action_invoke(&mut instance); + c539_l551_action_invoke(&mut instance); + c540_l552_action_invoke(&mut instance); + c541_l553_action_invoke(&mut instance); + c542_l554_action_invoke(&mut instance); + c543_l555_action_invoke(&mut instance); + c544_l556_action_invoke(&mut instance); + c545_l557_action_invoke(&mut instance); + c546_l558_action_invoke(&mut instance); + c547_l559_action_invoke(&mut instance); + c548_l560_action_invoke(&mut instance); + c549_l561_action_invoke(&mut instance); + c550_l562_action_invoke(&mut instance); + c551_l563_action_invoke(&mut instance); + c552_l564_action_invoke(&mut instance); + c553_l565_action_invoke(&mut instance); + c554_l566_action_invoke(&mut instance); + c555_l567_action_invoke(&mut instance); + c556_l568_action_invoke(&mut instance); + c557_l569_action_invoke(&mut instance); + c558_l570_action_invoke(&mut instance); + c559_l571_action_invoke(&mut instance); + c560_l572_action_invoke(&mut instance); + c561_l573_action_invoke(&mut instance); + c562_l574_action_invoke(&mut instance); + c563_l575_action_invoke(&mut instance); + c564_l576_action_invoke(&mut instance); + c565_l577_action_invoke(&mut instance); + c566_l578_action_invoke(&mut instance); + c567_l579_action_invoke(&mut instance); + c568_l580_action_invoke(&mut instance); + c569_l581_action_invoke(&mut instance); + c570_l582_action_invoke(&mut instance); + c571_l583_action_invoke(&mut instance); + c572_l584_action_invoke(&mut instance); + c573_l585_action_invoke(&mut instance); + c574_l586_action_invoke(&mut instance); + c575_l587_action_invoke(&mut instance); + c576_l588_action_invoke(&mut instance); + c577_l589_action_invoke(&mut instance); + c578_l590_action_invoke(&mut instance); + c579_l591_action_invoke(&mut instance); + c580_l592_action_invoke(&mut instance); + c581_l593_action_invoke(&mut instance); + c582_l594_action_invoke(&mut instance); + c583_l595_action_invoke(&mut instance); + c584_l596_action_invoke(&mut instance); + c585_l597_action_invoke(&mut instance); + c586_l598_action_invoke(&mut instance); + c587_l599_action_invoke(&mut instance); + c588_l600_action_invoke(&mut instance); + c589_l601_action_invoke(&mut instance); + c590_l602_action_invoke(&mut instance); + c591_l603_action_invoke(&mut instance); + c592_l604_action_invoke(&mut instance); + c593_l605_action_invoke(&mut instance); + c594_l606_action_invoke(&mut instance); + c595_l607_action_invoke(&mut instance); + c596_l608_action_invoke(&mut instance); + c597_l609_action_invoke(&mut instance); + c598_l610_action_invoke(&mut instance); + c599_l611_action_invoke(&mut instance); + c600_l612_action_invoke(&mut instance); + c601_l613_action_invoke(&mut instance); + c602_l614_action_invoke(&mut instance); + c603_l615_action_invoke(&mut instance); + c604_l616_action_invoke(&mut instance); + c605_l617_action_invoke(&mut instance); + c606_l618_action_invoke(&mut instance); + c607_l619_action_invoke(&mut instance); + c608_l620_action_invoke(&mut instance); + c609_l621_action_invoke(&mut instance); + c610_l622_action_invoke(&mut instance); + c611_l623_action_invoke(&mut instance); + c612_l624_action_invoke(&mut instance); + c613_l625_action_invoke(&mut instance); + c614_l626_action_invoke(&mut instance); + c615_l627_action_invoke(&mut instance); + c616_l628_action_invoke(&mut instance); + c617_l629_action_invoke(&mut instance); + c618_l630_action_invoke(&mut instance); + c619_l631_action_invoke(&mut instance); + c620_l632_action_invoke(&mut instance); + c621_l633_action_invoke(&mut instance); + c622_l634_action_invoke(&mut instance); + c623_l635_action_invoke(&mut instance); + c624_l636_action_invoke(&mut instance); + c625_l637_action_invoke(&mut instance); + c626_l638_action_invoke(&mut instance); + c627_l639_action_invoke(&mut instance); + c628_l640_action_invoke(&mut instance); + c629_l641_action_invoke(&mut instance); + c630_l642_action_invoke(&mut instance); + c631_l643_action_invoke(&mut instance); + c632_l644_action_invoke(&mut instance); + c633_l645_action_invoke(&mut instance); + c634_l646_action_invoke(&mut instance); + c635_l647_action_invoke(&mut instance); + c636_l648_action_invoke(&mut instance); + c637_l649_action_invoke(&mut instance); + c638_l650_action_invoke(&mut instance); + c639_l651_action_invoke(&mut instance); + c640_l652_action_invoke(&mut instance); + c641_l653_action_invoke(&mut instance); + c642_l654_action_invoke(&mut instance); + c643_l655_action_invoke(&mut instance); + c644_l656_action_invoke(&mut instance); + c645_l657_action_invoke(&mut instance); + c646_l658_action_invoke(&mut instance); + c647_l659_action_invoke(&mut instance); + c648_l660_action_invoke(&mut instance); + c649_l661_action_invoke(&mut instance); + c650_l662_action_invoke(&mut instance); + c651_l663_action_invoke(&mut instance); + c652_l664_action_invoke(&mut instance); + c653_l665_action_invoke(&mut instance); + c654_l666_action_invoke(&mut instance); + c655_l667_action_invoke(&mut instance); + c656_l668_action_invoke(&mut instance); + c657_l669_action_invoke(&mut instance); + c658_l670_action_invoke(&mut instance); + c659_l671_action_invoke(&mut instance); + c660_l672_action_invoke(&mut instance); + c661_l673_action_invoke(&mut instance); + c662_l674_action_invoke(&mut instance); + c663_l675_action_invoke(&mut instance); + c664_l676_action_invoke(&mut instance); + c665_l677_action_invoke(&mut instance); + c666_l678_action_invoke(&mut instance); + c667_l679_action_invoke(&mut instance); + c668_l680_action_invoke(&mut instance); + c669_l681_action_invoke(&mut instance); + c670_l682_action_invoke(&mut instance); + c671_l683_action_invoke(&mut instance); + c672_l684_action_invoke(&mut instance); + c673_l685_action_invoke(&mut instance); + c674_l686_action_invoke(&mut instance); + c675_l687_action_invoke(&mut instance); + c676_l688_action_invoke(&mut instance); + c677_l689_action_invoke(&mut instance); + c678_l690_action_invoke(&mut instance); + c679_l691_action_invoke(&mut instance); + c680_l692_action_invoke(&mut instance); + c681_l693_action_invoke(&mut instance); + c682_l694_action_invoke(&mut instance); + c683_l695_action_invoke(&mut instance); + c684_l696_action_invoke(&mut instance); + c685_l697_action_invoke(&mut instance); + c686_l698_action_invoke(&mut instance); + c687_l699_action_invoke(&mut instance); + c688_l700_action_invoke(&mut instance); + c689_l701_action_invoke(&mut instance); + c690_l702_action_invoke(&mut instance); + c691_l703_action_invoke(&mut instance); + c692_l704_action_invoke(&mut instance); + c693_l705_action_invoke(&mut instance); + c694_l706_action_invoke(&mut instance); + c695_l707_action_invoke(&mut instance); + c696_l708_action_invoke(&mut instance); + c697_l709_action_invoke(&mut instance); + c698_l710_action_invoke(&mut instance); + c699_l711_action_invoke(&mut instance); + c700_l712_action_invoke(&mut instance); + c701_l713_action_invoke(&mut instance); + c702_l714_action_invoke(&mut instance); + c703_l715_action_invoke(&mut instance); + c704_l716_action_invoke(&mut instance); + c705_l717_action_invoke(&mut instance); + c706_l718_action_invoke(&mut instance); + c707_l719_action_invoke(&mut instance); + c708_l720_action_invoke(&mut instance); + c709_l721_action_invoke(&mut instance); + c710_l722_action_invoke(&mut instance); + c711_l723_action_invoke(&mut instance); + c712_l724_action_invoke(&mut instance); + c713_l725_action_invoke(&mut instance); + c714_l726_action_invoke(&mut instance); + c715_l727_action_invoke(&mut instance); + c716_l728_action_invoke(&mut instance); + c717_l729_action_invoke(&mut instance); + c718_l730_action_invoke(&mut instance); + c719_l731_action_invoke(&mut instance); + c720_l732_action_invoke(&mut instance); + c721_l733_action_invoke(&mut instance); + c722_l734_action_invoke(&mut instance); + c723_l735_action_invoke(&mut instance); + c724_l736_action_invoke(&mut instance); + c725_l737_action_invoke(&mut instance); + c726_l738_action_invoke(&mut instance); + c727_l739_action_invoke(&mut instance); + c728_l740_action_invoke(&mut instance); + c729_l741_action_invoke(&mut instance); + c730_l742_action_invoke(&mut instance); + c731_l743_action_invoke(&mut instance); + c732_l744_action_invoke(&mut instance); + c733_l745_action_invoke(&mut instance); + c734_l746_action_invoke(&mut instance); + c735_l747_action_invoke(&mut instance); + c736_l748_action_invoke(&mut instance); + c737_l749_action_invoke(&mut instance); + c738_l750_action_invoke(&mut instance); + c739_l751_action_invoke(&mut instance); + c740_l752_action_invoke(&mut instance); + c741_l753_action_invoke(&mut instance); + c742_l754_action_invoke(&mut instance); + c743_l755_action_invoke(&mut instance); + c744_l756_action_invoke(&mut instance); + c745_l757_action_invoke(&mut instance); + c746_l758_action_invoke(&mut instance); + c747_l759_action_invoke(&mut instance); + c748_l760_action_invoke(&mut instance); + c749_l761_action_invoke(&mut instance); + c750_l762_action_invoke(&mut instance); + c751_l763_action_invoke(&mut instance); + c752_l764_action_invoke(&mut instance); + c753_l765_action_invoke(&mut instance); + c754_l766_action_invoke(&mut instance); + c755_l767_action_invoke(&mut instance); + c756_l768_action_invoke(&mut instance); + c757_l769_action_invoke(&mut instance); + c758_l770_action_invoke(&mut instance); + c759_l771_action_invoke(&mut instance); + c760_l772_action_invoke(&mut instance); + c761_l773_action_invoke(&mut instance); + c762_l774_action_invoke(&mut instance); + c763_l775_action_invoke(&mut instance); + c764_l776_action_invoke(&mut instance); + c765_l777_action_invoke(&mut instance); + c766_l778_action_invoke(&mut instance); + c767_l779_action_invoke(&mut instance); + c768_l780_action_invoke(&mut instance); + c769_l781_action_invoke(&mut instance); + c770_l782_action_invoke(&mut instance); + c771_l783_action_invoke(&mut instance); + c772_l784_action_invoke(&mut instance); + c773_l785_action_invoke(&mut instance); + c774_l786_action_invoke(&mut instance); + c775_l787_action_invoke(&mut instance); + c776_l788_action_invoke(&mut instance); + c777_l789_action_invoke(&mut instance); + c778_l790_action_invoke(&mut instance); + c779_l791_action_invoke(&mut instance); + c780_l792_action_invoke(&mut instance); + c781_l793_action_invoke(&mut instance); + c782_l794_action_invoke(&mut instance); + c783_l795_action_invoke(&mut instance); + c784_l796_action_invoke(&mut instance); + c785_l797_action_invoke(&mut instance); + c786_l798_action_invoke(&mut instance); + c787_l799_action_invoke(&mut instance); + c788_l800_action_invoke(&mut instance); + c789_l801_action_invoke(&mut instance); + c790_l802_action_invoke(&mut instance); + c791_l803_action_invoke(&mut instance); + c792_l804_action_invoke(&mut instance); + c793_l805_action_invoke(&mut instance); + c794_l806_action_invoke(&mut instance); + c795_l807_action_invoke(&mut instance); + c796_l808_action_invoke(&mut instance); + c797_l809_action_invoke(&mut instance); + c798_l810_action_invoke(&mut instance); + c799_l811_action_invoke(&mut instance); + c800_l812_action_invoke(&mut instance); + c801_l813_action_invoke(&mut instance); + c802_l814_action_invoke(&mut instance); + c803_l815_action_invoke(&mut instance); + c804_l816_action_invoke(&mut instance); + c805_l817_action_invoke(&mut instance); + c806_l818_action_invoke(&mut instance); + c807_l819_action_invoke(&mut instance); + c808_l820_action_invoke(&mut instance); + c809_l821_action_invoke(&mut instance); + c810_l822_action_invoke(&mut instance); + c811_l823_action_invoke(&mut instance); + c812_l824_action_invoke(&mut instance); + c813_l825_action_invoke(&mut instance); + c814_l826_action_invoke(&mut instance); + c815_l827_action_invoke(&mut instance); + c816_l828_action_invoke(&mut instance); + c817_l829_action_invoke(&mut instance); + c818_l830_action_invoke(&mut instance); + c819_l831_action_invoke(&mut instance); + c820_l832_action_invoke(&mut instance); + c821_l833_action_invoke(&mut instance); + c822_l834_action_invoke(&mut instance); + c823_l835_action_invoke(&mut instance); + c824_l836_action_invoke(&mut instance); + c825_l837_action_invoke(&mut instance); + c826_l838_action_invoke(&mut instance); + c827_l839_action_invoke(&mut instance); + c828_l840_action_invoke(&mut instance); + c829_l841_action_invoke(&mut instance); + c830_l842_action_invoke(&mut instance); + c831_l843_action_invoke(&mut instance); + c832_l844_action_invoke(&mut instance); + c833_l845_action_invoke(&mut instance); + c834_l846_action_invoke(&mut instance); + c835_l847_action_invoke(&mut instance); + c836_l848_action_invoke(&mut instance); + c837_l849_action_invoke(&mut instance); + c838_l850_action_invoke(&mut instance); + c839_l851_action_invoke(&mut instance); + c840_l852_action_invoke(&mut instance); + c841_l853_action_invoke(&mut instance); + c842_l854_action_invoke(&mut instance); + c843_l855_action_invoke(&mut instance); + c844_l856_action_invoke(&mut instance); + c845_l857_action_invoke(&mut instance); + c846_l858_action_invoke(&mut instance); + c847_l859_action_invoke(&mut instance); + c848_l860_action_invoke(&mut instance); + c849_l861_action_invoke(&mut instance); + c850_l862_action_invoke(&mut instance); + c851_l863_action_invoke(&mut instance); + c852_l864_action_invoke(&mut instance); + c853_l865_action_invoke(&mut instance); + c854_l866_action_invoke(&mut instance); + c855_l867_action_invoke(&mut instance); + c856_l868_action_invoke(&mut instance); + c857_l869_action_invoke(&mut instance); + c858_l870_action_invoke(&mut instance); + c859_l871_action_invoke(&mut instance); + c860_l872_action_invoke(&mut instance); + c861_l873_action_invoke(&mut instance); + c862_l874_action_invoke(&mut instance); + c863_l875_action_invoke(&mut instance); + c864_l876_action_invoke(&mut instance); + c865_l877_action_invoke(&mut instance); + c866_l878_action_invoke(&mut instance); + c867_l879_action_invoke(&mut instance); + c868_l880_action_invoke(&mut instance); + c869_l881_action_invoke(&mut instance); + c870_l882_action_invoke(&mut instance); + c871_l883_action_invoke(&mut instance); + c872_l884_action_invoke(&mut instance); + c873_l885_action_invoke(&mut instance); + c874_l886_action_invoke(&mut instance); + c875_l887_action_invoke(&mut instance); + c876_l888_action_invoke(&mut instance); + c877_l889_action_invoke(&mut instance); + c878_l890_action_invoke(&mut instance); + c879_l891_action_invoke(&mut instance); + c880_l892_action_invoke(&mut instance); + c881_l893_action_invoke(&mut instance); + c882_l894_action_invoke(&mut instance); + c883_l895_action_invoke(&mut instance); + c884_l896_action_invoke(&mut instance); + c885_l897_action_invoke(&mut instance); + c886_l898_action_invoke(&mut instance); + c887_l899_action_invoke(&mut instance); + c888_l900_action_invoke(&mut instance); + c889_l901_action_invoke(&mut instance); + c890_l902_action_invoke(&mut instance); + c891_l903_action_invoke(&mut instance); + c892_l904_action_invoke(&mut instance); + c893_l905_action_invoke(&mut instance); + c894_l906_action_invoke(&mut instance); + c895_l907_action_invoke(&mut instance); + c896_l908_action_invoke(&mut instance); + c897_l909_action_invoke(&mut instance); + c898_l910_action_invoke(&mut instance); + c899_l911_action_invoke(&mut instance); + c900_l912_action_invoke(&mut instance); + c901_l913_action_invoke(&mut instance); + c902_l914_action_invoke(&mut instance); + c903_l915_action_invoke(&mut instance); + c904_l916_action_invoke(&mut instance); + c905_l917_action_invoke(&mut instance); + c906_l918_action_invoke(&mut instance); + c907_l919_action_invoke(&mut instance); + c908_l920_action_invoke(&mut instance); + c909_l921_action_invoke(&mut instance); + c910_l922_action_invoke(&mut instance); + c911_l923_action_invoke(&mut instance); + c912_l924_action_invoke(&mut instance); + c913_l925_action_invoke(&mut instance); + c914_l926_action_invoke(&mut instance); + c915_l927_action_invoke(&mut instance); + c916_l928_action_invoke(&mut instance); + c917_l929_action_invoke(&mut instance); + c918_l930_action_invoke(&mut instance); + c919_l931_action_invoke(&mut instance); + c920_l932_action_invoke(&mut instance); + c921_l933_action_invoke(&mut instance); + c922_l934_action_invoke(&mut instance); + c923_l935_action_invoke(&mut instance); + c924_l936_action_invoke(&mut instance); + c925_l937_action_invoke(&mut instance); + c926_l938_action_invoke(&mut instance); + c927_l939_action_invoke(&mut instance); + c928_l940_action_invoke(&mut instance); + c929_l941_action_invoke(&mut instance); + c930_l942_action_invoke(&mut instance); + c931_l943_action_invoke(&mut instance); + c932_l944_action_invoke(&mut instance); + c933_l945_action_invoke(&mut instance); + c934_l946_action_invoke(&mut instance); + c935_l947_action_invoke(&mut instance); + c936_l948_action_invoke(&mut instance); + c937_l949_action_invoke(&mut instance); + c938_l950_action_invoke(&mut instance); + c939_l951_action_invoke(&mut instance); + c940_l952_action_invoke(&mut instance); + c941_l953_action_invoke(&mut instance); + c942_l954_action_invoke(&mut instance); + c943_l955_action_invoke(&mut instance); + c944_l956_action_invoke(&mut instance); + c945_l957_action_invoke(&mut instance); + c946_l958_action_invoke(&mut instance); + c947_l959_action_invoke(&mut instance); + c948_l960_action_invoke(&mut instance); + c949_l961_action_invoke(&mut instance); + c950_l962_action_invoke(&mut instance); + c951_l963_action_invoke(&mut instance); + c952_l964_action_invoke(&mut instance); + c953_l965_action_invoke(&mut instance); + c954_l966_action_invoke(&mut instance); + c955_l967_action_invoke(&mut instance); + c956_l968_action_invoke(&mut instance); + c957_l969_action_invoke(&mut instance); + c958_l970_action_invoke(&mut instance); + c959_l971_action_invoke(&mut instance); + c960_l972_action_invoke(&mut instance); + c961_l973_action_invoke(&mut instance); + c962_l974_action_invoke(&mut instance); + c963_l975_action_invoke(&mut instance); + c964_l976_action_invoke(&mut instance); + c965_l977_action_invoke(&mut instance); + c966_l978_action_invoke(&mut instance); + c967_l979_action_invoke(&mut instance); + c968_l980_action_invoke(&mut instance); + c969_l981_action_invoke(&mut instance); + c970_l982_action_invoke(&mut instance); + c971_l983_action_invoke(&mut instance); + c972_l984_action_invoke(&mut instance); + c973_l985_action_invoke(&mut instance); + c974_l986_action_invoke(&mut instance); + c975_l987_action_invoke(&mut instance); + c976_l988_action_invoke(&mut instance); + c977_l989_action_invoke(&mut instance); + c978_l990_action_invoke(&mut instance); + c979_l991_action_invoke(&mut instance); + c980_l992_action_invoke(&mut instance); + c981_l993_action_invoke(&mut instance); + c982_l994_action_invoke(&mut instance); + c983_l995_action_invoke(&mut instance); + c984_l996_action_invoke(&mut instance); + c985_l997_action_invoke(&mut instance); + c986_l998_action_invoke(&mut instance); + c987_l999_action_invoke(&mut instance); + c988_l1000_action_invoke(&mut instance); + c989_l1001_action_invoke(&mut instance); + c990_l1002_action_invoke(&mut instance); + c991_l1003_action_invoke(&mut instance); + c992_l1004_action_invoke(&mut instance); + c993_l1005_action_invoke(&mut instance); + c994_l1006_action_invoke(&mut instance); + c995_l1007_action_invoke(&mut instance); + c996_l1008_action_invoke(&mut instance); + c997_l1009_action_invoke(&mut instance); + c998_l1010_action_invoke(&mut instance); + c999_l1011_action_invoke(&mut instance); + c1000_l1012_action_invoke(&mut instance); + c1001_l1013_action_invoke(&mut instance); + c1002_l1014_action_invoke(&mut instance); + c1003_l1015_action_invoke(&mut instance); + c1004_l1016_action_invoke(&mut instance); + c1005_l1017_action_invoke(&mut instance); + c1006_l1018_action_invoke(&mut instance); + c1007_l1019_action_invoke(&mut instance); + c1008_l1020_action_invoke(&mut instance); + c1009_l1021_action_invoke(&mut instance); + c1010_l1022_action_invoke(&mut instance); + c1011_l1023_action_invoke(&mut instance); + c1012_l1024_action_invoke(&mut instance); + c1013_l1025_action_invoke(&mut instance); + c1014_l1026_action_invoke(&mut instance); + c1015_l1027_action_invoke(&mut instance); + c1016_l1028_action_invoke(&mut instance); + c1017_l1029_action_invoke(&mut instance); + c1018_l1030_action_invoke(&mut instance); + c1019_l1031_action_invoke(&mut instance); + c1020_l1032_action_invoke(&mut instance); + c1021_l1033_action_invoke(&mut instance); + c1022_l1034_action_invoke(&mut instance); + c1023_l1035_action_invoke(&mut instance); + c1024_l1036_action_invoke(&mut instance); + c1025_l1037_action_invoke(&mut instance); + c1026_l1038_action_invoke(&mut instance); + c1027_l1039_action_invoke(&mut instance); + c1028_l1040_action_invoke(&mut instance); + c1029_l1041_action_invoke(&mut instance); + c1030_l1042_action_invoke(&mut instance); + c1031_l1043_action_invoke(&mut instance); + c1032_l1044_action_invoke(&mut instance); + c1033_l1045_action_invoke(&mut instance); + c1034_l1046_action_invoke(&mut instance); + c1035_l1047_action_invoke(&mut instance); + c1036_l1048_action_invoke(&mut instance); + c1037_l1049_action_invoke(&mut instance); + c1038_l1050_action_invoke(&mut instance); + c1039_l1051_action_invoke(&mut instance); + c1040_l1052_action_invoke(&mut instance); + c1041_l1053_action_invoke(&mut instance); + c1042_l1054_action_invoke(&mut instance); + c1043_l1055_action_invoke(&mut instance); + c1044_l1056_action_invoke(&mut instance); + c1045_l1057_action_invoke(&mut instance); + c1046_l1058_action_invoke(&mut instance); + c1047_l1059_action_invoke(&mut instance); + c1048_l1060_action_invoke(&mut instance); + c1049_l1061_action_invoke(&mut instance); + c1050_l1062_action_invoke(&mut instance); + c1051_l1063_action_invoke(&mut instance); + c1052_l1064_action_invoke(&mut instance); + c1053_l1065_action_invoke(&mut instance); + c1054_l1066_action_invoke(&mut instance); + c1055_l1067_action_invoke(&mut instance); + c1056_l1068_action_invoke(&mut instance); + c1057_l1069_action_invoke(&mut instance); + c1058_l1070_action_invoke(&mut instance); + c1059_l1071_action_invoke(&mut instance); + c1060_l1072_action_invoke(&mut instance); + c1061_l1073_action_invoke(&mut instance); + c1062_l1074_action_invoke(&mut instance); + c1063_l1075_action_invoke(&mut instance); + c1064_l1076_action_invoke(&mut instance); + c1065_l1077_action_invoke(&mut instance); + c1066_l1078_action_invoke(&mut instance); + c1067_l1079_action_invoke(&mut instance); + c1068_l1080_action_invoke(&mut instance); + c1069_l1081_action_invoke(&mut instance); + c1070_l1082_action_invoke(&mut instance); + c1071_l1083_action_invoke(&mut instance); + c1072_l1084_action_invoke(&mut instance); + c1073_l1085_action_invoke(&mut instance); + c1074_l1086_action_invoke(&mut instance); + c1075_l1087_action_invoke(&mut instance); + c1076_l1088_action_invoke(&mut instance); + c1077_l1089_action_invoke(&mut instance); + c1078_l1090_action_invoke(&mut instance); + c1079_l1091_action_invoke(&mut instance); + c1080_l1092_action_invoke(&mut instance); + c1081_l1093_action_invoke(&mut instance); + c1082_l1094_action_invoke(&mut instance); + c1083_l1095_action_invoke(&mut instance); + c1084_l1096_action_invoke(&mut instance); + c1085_l1097_action_invoke(&mut instance); + c1086_l1098_action_invoke(&mut instance); + c1087_l1099_action_invoke(&mut instance); + c1088_l1100_action_invoke(&mut instance); + c1089_l1101_action_invoke(&mut instance); + c1090_l1102_action_invoke(&mut instance); + c1091_l1103_action_invoke(&mut instance); + c1092_l1104_action_invoke(&mut instance); + c1093_l1105_action_invoke(&mut instance); + c1094_l1106_action_invoke(&mut instance); + c1095_l1107_action_invoke(&mut instance); + c1096_l1108_action_invoke(&mut instance); + c1097_l1109_action_invoke(&mut instance); + c1098_l1110_action_invoke(&mut instance); + c1099_l1111_action_invoke(&mut instance); + c1100_l1112_action_invoke(&mut instance); + c1101_l1113_action_invoke(&mut instance); + c1102_l1114_action_invoke(&mut instance); + c1103_l1115_action_invoke(&mut instance); + c1104_l1116_action_invoke(&mut instance); + c1105_l1117_action_invoke(&mut instance); + c1106_l1118_action_invoke(&mut instance); + c1107_l1119_action_invoke(&mut instance); + c1108_l1120_action_invoke(&mut instance); + c1109_l1121_action_invoke(&mut instance); + c1110_l1122_action_invoke(&mut instance); + c1111_l1123_action_invoke(&mut instance); + c1112_l1124_action_invoke(&mut instance); + c1113_l1125_action_invoke(&mut instance); + c1114_l1126_action_invoke(&mut instance); + c1115_l1127_action_invoke(&mut instance); + c1116_l1128_action_invoke(&mut instance); + c1117_l1129_action_invoke(&mut instance); + c1118_l1130_action_invoke(&mut instance); + c1119_l1131_action_invoke(&mut instance); + c1120_l1132_action_invoke(&mut instance); + c1121_l1133_action_invoke(&mut instance); + c1122_l1134_action_invoke(&mut instance); + c1123_l1135_action_invoke(&mut instance); + c1124_l1136_action_invoke(&mut instance); + c1125_l1137_action_invoke(&mut instance); + c1126_l1138_action_invoke(&mut instance); + c1127_l1139_action_invoke(&mut instance); + c1128_l1140_action_invoke(&mut instance); + c1129_l1141_action_invoke(&mut instance); + c1130_l1142_action_invoke(&mut instance); + c1131_l1143_action_invoke(&mut instance); + c1132_l1144_action_invoke(&mut instance); + c1133_l1145_action_invoke(&mut instance); + c1134_l1146_action_invoke(&mut instance); + c1135_l1147_action_invoke(&mut instance); + c1136_l1148_action_invoke(&mut instance); + c1137_l1149_action_invoke(&mut instance); + c1138_l1150_action_invoke(&mut instance); + c1139_l1151_action_invoke(&mut instance); + c1140_l1152_action_invoke(&mut instance); + c1141_l1153_action_invoke(&mut instance); + c1142_l1154_action_invoke(&mut instance); + c1143_l1155_action_invoke(&mut instance); + c1144_l1156_action_invoke(&mut instance); + c1145_l1157_action_invoke(&mut instance); + c1146_l1158_action_invoke(&mut instance); + c1147_l1159_action_invoke(&mut instance); + c1148_l1160_action_invoke(&mut instance); + c1149_l1161_action_invoke(&mut instance); + c1150_l1162_action_invoke(&mut instance); + c1151_l1163_action_invoke(&mut instance); + c1152_l1164_action_invoke(&mut instance); + c1153_l1165_action_invoke(&mut instance); + c1154_l1166_action_invoke(&mut instance); + c1155_l1167_action_invoke(&mut instance); + c1156_l1168_action_invoke(&mut instance); + c1157_l1169_action_invoke(&mut instance); + c1158_l1170_action_invoke(&mut instance); + c1159_l1171_action_invoke(&mut instance); + c1160_l1172_action_invoke(&mut instance); + c1161_l1173_action_invoke(&mut instance); + c1162_l1174_action_invoke(&mut instance); + c1163_l1175_action_invoke(&mut instance); + c1164_l1176_action_invoke(&mut instance); + c1165_l1177_action_invoke(&mut instance); + c1166_l1178_action_invoke(&mut instance); + c1167_l1179_action_invoke(&mut instance); + c1168_l1180_action_invoke(&mut instance); + c1169_l1181_action_invoke(&mut instance); + c1170_l1182_action_invoke(&mut instance); + c1171_l1183_action_invoke(&mut instance); + c1172_l1184_action_invoke(&mut instance); + c1173_l1185_action_invoke(&mut instance); + c1174_l1186_action_invoke(&mut instance); + c1175_l1187_action_invoke(&mut instance); + c1176_l1188_action_invoke(&mut instance); + c1177_l1189_action_invoke(&mut instance); + c1178_l1190_action_invoke(&mut instance); + c1179_l1191_action_invoke(&mut instance); + c1180_l1192_action_invoke(&mut instance); + c1181_l1193_action_invoke(&mut instance); + c1182_l1194_action_invoke(&mut instance); + c1183_l1195_action_invoke(&mut instance); + c1184_l1196_action_invoke(&mut instance); + c1185_l1197_action_invoke(&mut instance); + c1186_l1198_action_invoke(&mut instance); + c1187_l1199_action_invoke(&mut instance); + c1188_l1200_action_invoke(&mut instance); + c1189_l1201_action_invoke(&mut instance); + c1190_l1202_action_invoke(&mut instance); + c1191_l1203_action_invoke(&mut instance); + c1192_l1204_action_invoke(&mut instance); + c1193_l1205_action_invoke(&mut instance); + c1194_l1206_action_invoke(&mut instance); + c1195_l1207_action_invoke(&mut instance); + c1196_l1208_action_invoke(&mut instance); + c1197_l1209_action_invoke(&mut instance); + c1198_l1210_action_invoke(&mut instance); + c1199_l1211_action_invoke(&mut instance); + c1200_l1212_action_invoke(&mut instance); + c1201_l1213_action_invoke(&mut instance); + c1202_l1214_action_invoke(&mut instance); + c1203_l1215_action_invoke(&mut instance); + c1204_l1216_action_invoke(&mut instance); + c1205_l1217_action_invoke(&mut instance); + c1206_l1218_action_invoke(&mut instance); + c1207_l1219_action_invoke(&mut instance); + c1208_l1220_action_invoke(&mut instance); + c1209_l1221_action_invoke(&mut instance); + c1210_l1222_action_invoke(&mut instance); + c1211_l1223_action_invoke(&mut instance); + c1212_l1224_action_invoke(&mut instance); + c1213_l1225_action_invoke(&mut instance); + c1214_l1226_action_invoke(&mut instance); + c1215_l1227_action_invoke(&mut instance); + c1216_l1228_action_invoke(&mut instance); + c1217_l1229_action_invoke(&mut instance); + c1218_l1230_action_invoke(&mut instance); + c1219_l1231_action_invoke(&mut instance); + c1220_l1232_action_invoke(&mut instance); + c1221_l1233_action_invoke(&mut instance); + c1222_l1234_action_invoke(&mut instance); + c1223_l1235_action_invoke(&mut instance); + c1224_l1236_action_invoke(&mut instance); + c1225_l1237_action_invoke(&mut instance); + c1226_l1238_action_invoke(&mut instance); + c1227_l1239_action_invoke(&mut instance); + c1228_l1240_action_invoke(&mut instance); + c1229_l1241_action_invoke(&mut instance); + c1230_l1242_action_invoke(&mut instance); + c1231_l1243_action_invoke(&mut instance); + c1232_l1244_action_invoke(&mut instance); + c1233_l1245_action_invoke(&mut instance); + c1234_l1246_action_invoke(&mut instance); + c1235_l1247_action_invoke(&mut instance); + c1236_l1248_action_invoke(&mut instance); + c1237_l1249_action_invoke(&mut instance); + c1238_l1250_action_invoke(&mut instance); + c1239_l1251_action_invoke(&mut instance); + c1240_l1252_action_invoke(&mut instance); + c1241_l1253_action_invoke(&mut instance); + c1242_l1254_action_invoke(&mut instance); + c1243_l1255_action_invoke(&mut instance); + c1244_l1256_action_invoke(&mut instance); + c1245_l1257_action_invoke(&mut instance); + c1246_l1258_action_invoke(&mut instance); + c1247_l1259_action_invoke(&mut instance); + c1248_l1260_action_invoke(&mut instance); + c1249_l1261_action_invoke(&mut instance); + c1250_l1262_action_invoke(&mut instance); + c1251_l1263_action_invoke(&mut instance); + c1252_l1264_action_invoke(&mut instance); + c1253_l1265_action_invoke(&mut instance); + c1254_l1266_action_invoke(&mut instance); + c1255_l1267_action_invoke(&mut instance); + c1256_l1268_action_invoke(&mut instance); + c1257_l1269_action_invoke(&mut instance); + c1258_l1270_action_invoke(&mut instance); + c1259_l1271_action_invoke(&mut instance); + c1260_l1272_action_invoke(&mut instance); + c1261_l1273_action_invoke(&mut instance); + c1262_l1274_action_invoke(&mut instance); + c1263_l1275_action_invoke(&mut instance); + c1264_l1276_action_invoke(&mut instance); + c1265_l1277_action_invoke(&mut instance); + c1266_l1278_action_invoke(&mut instance); + c1267_l1279_action_invoke(&mut instance); + c1268_l1280_action_invoke(&mut instance); + c1269_l1281_action_invoke(&mut instance); + c1270_l1282_action_invoke(&mut instance); + c1271_l1283_action_invoke(&mut instance); + c1272_l1284_action_invoke(&mut instance); + c1273_l1285_action_invoke(&mut instance); + c1274_l1286_action_invoke(&mut instance); + c1275_l1287_action_invoke(&mut instance); + c1276_l1288_action_invoke(&mut instance); + c1277_l1289_action_invoke(&mut instance); + c1278_l1290_action_invoke(&mut instance); + c1279_l1291_action_invoke(&mut instance); + c1280_l1292_action_invoke(&mut instance); + c1281_l1293_action_invoke(&mut instance); + c1282_l1294_action_invoke(&mut instance); + c1283_l1295_action_invoke(&mut instance); + c1284_l1296_action_invoke(&mut instance); + c1285_l1297_action_invoke(&mut instance); + c1286_l1298_action_invoke(&mut instance); + c1287_l1299_action_invoke(&mut instance); + c1288_l1300_action_invoke(&mut instance); + c1289_l1301_action_invoke(&mut instance); + c1290_l1302_action_invoke(&mut instance); + c1291_l1303_action_invoke(&mut instance); + c1292_l1304_action_invoke(&mut instance); + c1293_l1305_action_invoke(&mut instance); + c1294_l1306_action_invoke(&mut instance); + c1295_l1307_action_invoke(&mut instance); + c1296_l1308_action_invoke(&mut instance); + c1297_l1309_action_invoke(&mut instance); + c1298_l1310_action_invoke(&mut instance); + c1299_l1311_action_invoke(&mut instance); + c1300_l1312_action_invoke(&mut instance); + c1301_l1313_action_invoke(&mut instance); + c1302_l1314_action_invoke(&mut instance); + c1303_l1315_action_invoke(&mut instance); + c1304_l1316_action_invoke(&mut instance); + c1305_l1317_action_invoke(&mut instance); + c1306_l1318_action_invoke(&mut instance); + c1307_l1319_action_invoke(&mut instance); + c1308_l1320_action_invoke(&mut instance); + c1309_l1321_action_invoke(&mut instance); + c1310_l1322_action_invoke(&mut instance); + c1311_l1323_action_invoke(&mut instance); + c1312_l1324_action_invoke(&mut instance); + c1313_l1325_action_invoke(&mut instance); + c1314_l1326_action_invoke(&mut instance); + c1315_l1327_action_invoke(&mut instance); + c1316_l1328_action_invoke(&mut instance); + c1317_l1329_action_invoke(&mut instance); + c1318_l1330_action_invoke(&mut instance); + c1319_l1331_action_invoke(&mut instance); + c1320_l1332_action_invoke(&mut instance); + c1321_l1333_action_invoke(&mut instance); + c1322_l1334_action_invoke(&mut instance); + c1323_l1335_action_invoke(&mut instance); + c1324_l1336_action_invoke(&mut instance); + c1325_l1337_action_invoke(&mut instance); + c1326_l1338_action_invoke(&mut instance); + c1327_l1339_action_invoke(&mut instance); + c1328_l1340_action_invoke(&mut instance); + c1329_l1341_action_invoke(&mut instance); + c1330_l1342_action_invoke(&mut instance); + c1331_l1343_action_invoke(&mut instance); + c1332_l1344_action_invoke(&mut instance); + c1333_l1345_action_invoke(&mut instance); + c1334_l1346_action_invoke(&mut instance); + c1335_l1347_action_invoke(&mut instance); + c1336_l1348_action_invoke(&mut instance); + c1337_l1349_action_invoke(&mut instance); + c1338_l1350_action_invoke(&mut instance); + c1339_l1351_action_invoke(&mut instance); + c1340_l1352_action_invoke(&mut instance); + c1341_l1353_action_invoke(&mut instance); + c1342_l1354_action_invoke(&mut instance); + c1343_l1355_action_invoke(&mut instance); + c1344_l1356_action_invoke(&mut instance); + c1345_l1357_action_invoke(&mut instance); + c1346_l1358_action_invoke(&mut instance); + c1347_l1359_action_invoke(&mut instance); + c1348_l1360_action_invoke(&mut instance); + c1349_l1361_action_invoke(&mut instance); + c1350_l1362_action_invoke(&mut instance); + c1351_l1363_action_invoke(&mut instance); + c1352_l1364_action_invoke(&mut instance); + c1353_l1365_action_invoke(&mut instance); + c1354_l1366_action_invoke(&mut instance); + c1355_l1367_action_invoke(&mut instance); + c1356_l1368_action_invoke(&mut instance); + c1357_l1369_action_invoke(&mut instance); + c1358_l1370_action_invoke(&mut instance); + c1359_l1371_action_invoke(&mut instance); + c1360_l1372_action_invoke(&mut instance); + c1361_l1373_action_invoke(&mut instance); + c1362_l1374_action_invoke(&mut instance); + c1363_l1375_action_invoke(&mut instance); + c1364_l1376_action_invoke(&mut instance); + c1365_l1377_action_invoke(&mut instance); + c1366_l1378_action_invoke(&mut instance); + c1367_l1379_action_invoke(&mut instance); + c1368_l1380_action_invoke(&mut instance); + c1369_l1381_action_invoke(&mut instance); + c1370_l1382_action_invoke(&mut instance); + c1371_l1383_action_invoke(&mut instance); + c1372_l1384_action_invoke(&mut instance); + c1373_l1385_action_invoke(&mut instance); + c1374_l1386_action_invoke(&mut instance); + c1375_l1387_action_invoke(&mut instance); + c1376_l1388_action_invoke(&mut instance); + c1377_l1389_action_invoke(&mut instance); + c1378_l1390_action_invoke(&mut instance); + c1379_l1391_action_invoke(&mut instance); + c1380_l1392_action_invoke(&mut instance); + c1381_l1393_action_invoke(&mut instance); + c1382_l1394_action_invoke(&mut instance); + c1383_l1395_action_invoke(&mut instance); + c1384_l1396_action_invoke(&mut instance); + c1385_l1397_action_invoke(&mut instance); + c1386_l1398_action_invoke(&mut instance); + c1387_l1399_action_invoke(&mut instance); + c1388_l1400_action_invoke(&mut instance); + c1389_l1401_action_invoke(&mut instance); + c1390_l1402_action_invoke(&mut instance); + c1391_l1403_action_invoke(&mut instance); + c1392_l1404_action_invoke(&mut instance); + c1393_l1405_action_invoke(&mut instance); + c1394_l1406_action_invoke(&mut instance); + c1395_l1407_action_invoke(&mut instance); + c1396_l1408_action_invoke(&mut instance); + c1397_l1409_action_invoke(&mut instance); + c1398_l1410_action_invoke(&mut instance); + c1399_l1411_action_invoke(&mut instance); + c1400_l1412_action_invoke(&mut instance); + c1401_l1413_action_invoke(&mut instance); + c1402_l1414_action_invoke(&mut instance); + c1403_l1415_action_invoke(&mut instance); + c1404_l1416_action_invoke(&mut instance); + c1405_l1417_action_invoke(&mut instance); + c1406_l1418_action_invoke(&mut instance); + c1407_l1419_action_invoke(&mut instance); + c1408_l1420_action_invoke(&mut instance); + c1409_l1421_action_invoke(&mut instance); + c1410_l1422_action_invoke(&mut instance); + c1411_l1423_action_invoke(&mut instance); + c1412_l1424_action_invoke(&mut instance); + c1413_l1425_action_invoke(&mut instance); + c1414_l1426_action_invoke(&mut instance); + c1415_l1427_action_invoke(&mut instance); + c1416_l1428_action_invoke(&mut instance); + c1417_l1429_action_invoke(&mut instance); + c1418_l1430_action_invoke(&mut instance); + c1419_l1431_action_invoke(&mut instance); + c1420_l1432_action_invoke(&mut instance); + c1421_l1433_action_invoke(&mut instance); + c1422_l1434_action_invoke(&mut instance); + c1423_l1435_action_invoke(&mut instance); + c1424_l1436_action_invoke(&mut instance); + c1425_l1437_action_invoke(&mut instance); + c1426_l1438_action_invoke(&mut instance); + c1427_l1439_action_invoke(&mut instance); + c1428_l1440_action_invoke(&mut instance); + c1429_l1441_action_invoke(&mut instance); + c1430_l1442_action_invoke(&mut instance); + c1431_l1443_action_invoke(&mut instance); + c1432_l1444_action_invoke(&mut instance); + c1433_l1445_action_invoke(&mut instance); + c1434_l1446_action_invoke(&mut instance); + c1435_l1447_action_invoke(&mut instance); + c1436_l1448_action_invoke(&mut instance); + c1437_l1449_action_invoke(&mut instance); + c1438_l1450_action_invoke(&mut instance); + c1439_l1451_action_invoke(&mut instance); + c1440_l1452_action_invoke(&mut instance); + c1441_l1453_action_invoke(&mut instance); + c1442_l1454_action_invoke(&mut instance); + c1443_l1455_action_invoke(&mut instance); + c1444_l1456_action_invoke(&mut instance); + c1445_l1457_action_invoke(&mut instance); + c1446_l1458_action_invoke(&mut instance); + c1447_l1459_action_invoke(&mut instance); + c1448_l1460_action_invoke(&mut instance); + c1449_l1461_action_invoke(&mut instance); + c1450_l1462_action_invoke(&mut instance); + c1451_l1463_action_invoke(&mut instance); + c1452_l1464_action_invoke(&mut instance); + c1453_l1465_action_invoke(&mut instance); + c1454_l1466_action_invoke(&mut instance); + c1455_l1467_action_invoke(&mut instance); + c1456_l1468_action_invoke(&mut instance); + c1457_l1469_action_invoke(&mut instance); + c1458_l1470_action_invoke(&mut instance); + c1459_l1471_action_invoke(&mut instance); + c1460_l1472_action_invoke(&mut instance); + c1461_l1473_action_invoke(&mut instance); + c1462_l1474_action_invoke(&mut instance); + c1463_l1475_action_invoke(&mut instance); + c1464_l1476_action_invoke(&mut instance); + c1465_l1477_action_invoke(&mut instance); + c1466_l1478_action_invoke(&mut instance); + c1467_l1479_action_invoke(&mut instance); + c1468_l1480_action_invoke(&mut instance); + c1469_l1481_action_invoke(&mut instance); + c1470_l1482_action_invoke(&mut instance); + c1471_l1483_action_invoke(&mut instance); + c1472_l1484_action_invoke(&mut instance); + c1473_l1485_action_invoke(&mut instance); + c1474_l1486_action_invoke(&mut instance); + c1475_l1487_action_invoke(&mut instance); + c1476_l1488_action_invoke(&mut instance); + c1477_l1489_action_invoke(&mut instance); + c1478_l1490_action_invoke(&mut instance); + c1479_l1491_action_invoke(&mut instance); + c1480_l1492_action_invoke(&mut instance); + c1481_l1493_action_invoke(&mut instance); + c1482_l1494_action_invoke(&mut instance); + c1483_l1495_action_invoke(&mut instance); + c1484_l1496_action_invoke(&mut instance); + c1485_l1497_action_invoke(&mut instance); + c1486_l1498_action_invoke(&mut instance); + c1487_l1499_action_invoke(&mut instance); + c1488_l1500_action_invoke(&mut instance); + c1489_l1501_action_invoke(&mut instance); + c1490_l1502_action_invoke(&mut instance); + c1491_l1503_action_invoke(&mut instance); + c1492_l1504_action_invoke(&mut instance); + c1493_l1505_action_invoke(&mut instance); + c1494_l1506_action_invoke(&mut instance); + c1495_l1507_action_invoke(&mut instance); + c1496_l1508_action_invoke(&mut instance); + c1497_l1509_action_invoke(&mut instance); + c1498_l1510_action_invoke(&mut instance); + c1499_l1511_action_invoke(&mut instance); + c1500_l1512_action_invoke(&mut instance); + c1501_l1513_action_invoke(&mut instance); + c1502_l1514_action_invoke(&mut instance); + c1503_l1515_action_invoke(&mut instance); + c1504_l1516_action_invoke(&mut instance); + c1505_l1517_action_invoke(&mut instance); + c1506_l1518_action_invoke(&mut instance); + c1507_l1519_action_invoke(&mut instance); + c1508_l1520_action_invoke(&mut instance); + c1509_l1521_action_invoke(&mut instance); + c1510_l1522_action_invoke(&mut instance); + c1511_l1523_action_invoke(&mut instance); + c1512_l1524_action_invoke(&mut instance); + c1513_l1525_action_invoke(&mut instance); + c1514_l1526_action_invoke(&mut instance); + c1515_l1527_action_invoke(&mut instance); + c1516_l1528_action_invoke(&mut instance); + c1517_l1529_action_invoke(&mut instance); + c1518_l1530_action_invoke(&mut instance); + c1519_l1531_action_invoke(&mut instance); + c1520_l1532_action_invoke(&mut instance); + c1521_l1533_action_invoke(&mut instance); + c1522_l1534_action_invoke(&mut instance); + c1523_l1535_action_invoke(&mut instance); + c1524_l1536_action_invoke(&mut instance); + c1525_l1537_action_invoke(&mut instance); + c1526_l1538_action_invoke(&mut instance); + c1527_l1539_action_invoke(&mut instance); + c1528_l1540_action_invoke(&mut instance); + c1529_l1541_action_invoke(&mut instance); + c1530_l1542_action_invoke(&mut instance); + c1531_l1543_action_invoke(&mut instance); + c1532_l1544_action_invoke(&mut instance); + c1533_l1545_action_invoke(&mut instance); + c1534_l1546_action_invoke(&mut instance); + c1535_l1547_action_invoke(&mut instance); + c1536_l1548_action_invoke(&mut instance); + c1537_l1549_action_invoke(&mut instance); + c1538_l1550_action_invoke(&mut instance); + c1539_l1551_action_invoke(&mut instance); + c1540_l1552_action_invoke(&mut instance); + c1541_l1553_action_invoke(&mut instance); + c1542_l1554_action_invoke(&mut instance); + c1543_l1555_action_invoke(&mut instance); + c1544_l1556_action_invoke(&mut instance); + c1545_l1557_action_invoke(&mut instance); + c1546_l1558_action_invoke(&mut instance); + c1547_l1559_action_invoke(&mut instance); + c1548_l1560_action_invoke(&mut instance); + c1549_l1561_action_invoke(&mut instance); + c1550_l1562_action_invoke(&mut instance); + c1551_l1563_action_invoke(&mut instance); + c1552_l1564_action_invoke(&mut instance); + c1553_l1565_action_invoke(&mut instance); + c1554_l1566_action_invoke(&mut instance); + c1555_l1567_action_invoke(&mut instance); + c1556_l1568_action_invoke(&mut instance); + c1557_l1569_action_invoke(&mut instance); + c1558_l1570_action_invoke(&mut instance); + c1559_l1571_action_invoke(&mut instance); + c1560_l1572_action_invoke(&mut instance); + c1561_l1573_action_invoke(&mut instance); + c1562_l1574_action_invoke(&mut instance); + c1563_l1575_action_invoke(&mut instance); + c1564_l1576_action_invoke(&mut instance); + c1565_l1577_action_invoke(&mut instance); + c1566_l1578_action_invoke(&mut instance); + c1567_l1579_action_invoke(&mut instance); + c1568_l1580_action_invoke(&mut instance); + c1569_l1581_action_invoke(&mut instance); + c1570_l1582_action_invoke(&mut instance); + c1571_l1583_action_invoke(&mut instance); + c1572_l1584_action_invoke(&mut instance); + c1573_l1585_action_invoke(&mut instance); + c1574_l1586_action_invoke(&mut instance); + c1575_l1587_action_invoke(&mut instance); + c1576_l1588_action_invoke(&mut instance); + c1577_l1589_action_invoke(&mut instance); + c1578_l1590_action_invoke(&mut instance); + c1579_l1591_action_invoke(&mut instance); + c1580_l1592_action_invoke(&mut instance); + c1581_l1593_action_invoke(&mut instance); + c1582_l1594_action_invoke(&mut instance); + c1583_l1595_action_invoke(&mut instance); + c1584_l1596_action_invoke(&mut instance); + c1585_l1597_action_invoke(&mut instance); + c1586_l1598_action_invoke(&mut instance); + c1587_l1599_action_invoke(&mut instance); + c1588_l1600_action_invoke(&mut instance); + c1589_l1601_action_invoke(&mut instance); + c1590_l1602_action_invoke(&mut instance); + c1591_l1603_action_invoke(&mut instance); + c1592_l1604_action_invoke(&mut instance); + c1593_l1605_action_invoke(&mut instance); + c1594_l1606_action_invoke(&mut instance); + c1595_l1607_action_invoke(&mut instance); + c1596_l1608_action_invoke(&mut instance); + c1597_l1609_action_invoke(&mut instance); + c1598_l1610_action_invoke(&mut instance); + c1599_l1611_action_invoke(&mut instance); + c1600_l1612_action_invoke(&mut instance); + c1601_l1613_action_invoke(&mut instance); + c1602_l1614_action_invoke(&mut instance); + c1603_l1615_action_invoke(&mut instance); + c1604_l1616_action_invoke(&mut instance); + c1605_l1617_action_invoke(&mut instance); + c1606_l1618_action_invoke(&mut instance); + c1607_l1619_action_invoke(&mut instance); + c1608_l1620_action_invoke(&mut instance); + c1609_l1621_action_invoke(&mut instance); + c1610_l1622_action_invoke(&mut instance); + c1611_l1623_action_invoke(&mut instance); + c1612_l1624_action_invoke(&mut instance); + c1613_l1625_action_invoke(&mut instance); + c1614_l1626_action_invoke(&mut instance); + c1615_l1627_action_invoke(&mut instance); + c1616_l1628_action_invoke(&mut instance); + c1617_l1629_action_invoke(&mut instance); + c1618_l1630_action_invoke(&mut instance); + c1619_l1631_action_invoke(&mut instance); + c1620_l1632_action_invoke(&mut instance); + c1621_l1633_action_invoke(&mut instance); + c1622_l1634_action_invoke(&mut instance); + c1623_l1635_action_invoke(&mut instance); + c1624_l1636_action_invoke(&mut instance); + c1625_l1637_action_invoke(&mut instance); + c1626_l1638_action_invoke(&mut instance); + c1627_l1639_action_invoke(&mut instance); + c1628_l1640_action_invoke(&mut instance); + c1629_l1641_action_invoke(&mut instance); + c1630_l1642_action_invoke(&mut instance); + c1631_l1643_action_invoke(&mut instance); + c1632_l1644_action_invoke(&mut instance); + c1633_l1645_action_invoke(&mut instance); + c1634_l1646_action_invoke(&mut instance); + c1635_l1647_action_invoke(&mut instance); + c1636_l1648_action_invoke(&mut instance); + c1637_l1649_action_invoke(&mut instance); + c1638_l1650_action_invoke(&mut instance); + c1639_l1651_action_invoke(&mut instance); + c1640_l1652_action_invoke(&mut instance); + c1641_l1653_action_invoke(&mut instance); + c1642_l1654_action_invoke(&mut instance); + c1643_l1655_action_invoke(&mut instance); + c1644_l1656_action_invoke(&mut instance); + c1645_l1657_action_invoke(&mut instance); + c1646_l1658_action_invoke(&mut instance); + c1647_l1659_action_invoke(&mut instance); + c1648_l1660_action_invoke(&mut instance); + c1649_l1661_action_invoke(&mut instance); + c1650_l1662_action_invoke(&mut instance); + c1651_l1663_action_invoke(&mut instance); + c1652_l1664_action_invoke(&mut instance); + c1653_l1665_action_invoke(&mut instance); + c1654_l1666_action_invoke(&mut instance); + c1655_l1667_action_invoke(&mut instance); + c1656_l1668_action_invoke(&mut instance); + c1657_l1669_action_invoke(&mut instance); + c1658_l1670_action_invoke(&mut instance); + c1659_l1671_action_invoke(&mut instance); + c1660_l1672_action_invoke(&mut instance); + c1661_l1673_action_invoke(&mut instance); + c1662_l1674_action_invoke(&mut instance); + c1663_l1675_action_invoke(&mut instance); + c1664_l1676_action_invoke(&mut instance); + c1665_l1677_action_invoke(&mut instance); + c1666_l1678_action_invoke(&mut instance); + c1667_l1679_action_invoke(&mut instance); + c1668_l1680_action_invoke(&mut instance); + c1669_l1681_action_invoke(&mut instance); + c1670_l1682_action_invoke(&mut instance); + c1671_l1683_action_invoke(&mut instance); + c1672_l1684_action_invoke(&mut instance); + c1673_l1685_action_invoke(&mut instance); + c1674_l1686_action_invoke(&mut instance); + c1675_l1687_action_invoke(&mut instance); + c1676_l1688_action_invoke(&mut instance); + c1677_l1689_action_invoke(&mut instance); + c1678_l1690_action_invoke(&mut instance); + c1679_l1691_action_invoke(&mut instance); + c1680_l1692_action_invoke(&mut instance); + c1681_l1693_action_invoke(&mut instance); + c1682_l1694_action_invoke(&mut instance); + c1683_l1695_action_invoke(&mut instance); + c1684_l1696_action_invoke(&mut instance); + c1685_l1697_action_invoke(&mut instance); + c1686_l1698_action_invoke(&mut instance); + c1687_l1699_action_invoke(&mut instance); + c1688_l1700_action_invoke(&mut instance); + c1689_l1701_action_invoke(&mut instance); + c1690_l1702_action_invoke(&mut instance); + c1691_l1703_action_invoke(&mut instance); + c1692_l1704_action_invoke(&mut instance); + c1693_l1705_action_invoke(&mut instance); + c1694_l1706_action_invoke(&mut instance); + c1695_l1707_action_invoke(&mut instance); + c1696_l1708_action_invoke(&mut instance); + c1697_l1709_action_invoke(&mut instance); + c1698_l1710_action_invoke(&mut instance); + c1699_l1711_action_invoke(&mut instance); + c1700_l1712_action_invoke(&mut instance); + c1701_l1713_action_invoke(&mut instance); + c1702_l1714_action_invoke(&mut instance); + c1703_l1715_action_invoke(&mut instance); + c1704_l1716_action_invoke(&mut instance); + c1705_l1717_action_invoke(&mut instance); + c1706_l1718_action_invoke(&mut instance); + c1707_l1719_action_invoke(&mut instance); + c1708_l1720_action_invoke(&mut instance); + c1709_l1721_action_invoke(&mut instance); + c1710_l1722_action_invoke(&mut instance); + c1711_l1723_action_invoke(&mut instance); + c1712_l1724_action_invoke(&mut instance); + c1713_l1725_action_invoke(&mut instance); + c1714_l1726_action_invoke(&mut instance); + c1715_l1727_action_invoke(&mut instance); + c1716_l1728_action_invoke(&mut instance); + c1717_l1729_action_invoke(&mut instance); + c1718_l1730_action_invoke(&mut instance); + c1719_l1731_action_invoke(&mut instance); + c1720_l1732_action_invoke(&mut instance); + c1721_l1733_action_invoke(&mut instance); + c1722_l1734_action_invoke(&mut instance); + c1723_l1735_action_invoke(&mut instance); + c1724_l1736_action_invoke(&mut instance); + c1725_l1737_action_invoke(&mut instance); + c1726_l1738_action_invoke(&mut instance); + c1727_l1739_action_invoke(&mut instance); + c1728_l1740_action_invoke(&mut instance); + c1729_l1741_action_invoke(&mut instance); + c1730_l1742_action_invoke(&mut instance); + c1731_l1743_action_invoke(&mut instance); + c1732_l1744_action_invoke(&mut instance); + c1733_l1745_action_invoke(&mut instance); + c1734_l1746_action_invoke(&mut instance); + c1735_l1747_action_invoke(&mut instance); + c1736_l1748_action_invoke(&mut instance); + c1737_l1749_action_invoke(&mut instance); + c1738_l1750_action_invoke(&mut instance); + c1739_l1751_action_invoke(&mut instance); + c1740_l1752_action_invoke(&mut instance); + c1741_l1753_action_invoke(&mut instance); + c1742_l1754_action_invoke(&mut instance); + c1743_l1755_action_invoke(&mut instance); + c1744_l1756_action_invoke(&mut instance); + c1745_l1757_action_invoke(&mut instance); + c1746_l1758_action_invoke(&mut instance); + c1747_l1759_action_invoke(&mut instance); + c1748_l1760_action_invoke(&mut instance); + c1749_l1761_action_invoke(&mut instance); + c1750_l1762_action_invoke(&mut instance); + c1751_l1763_action_invoke(&mut instance); + c1752_l1764_action_invoke(&mut instance); + c1753_l1765_action_invoke(&mut instance); + c1754_l1766_action_invoke(&mut instance); + c1755_l1767_action_invoke(&mut instance); + c1756_l1768_action_invoke(&mut instance); + c1757_l1769_action_invoke(&mut instance); + c1758_l1770_action_invoke(&mut instance); + c1759_l1771_action_invoke(&mut instance); + c1760_l1772_action_invoke(&mut instance); + c1761_l1773_action_invoke(&mut instance); + c1762_l1774_action_invoke(&mut instance); + c1763_l1775_action_invoke(&mut instance); + c1764_l1776_action_invoke(&mut instance); + c1765_l1777_action_invoke(&mut instance); + c1766_l1778_action_invoke(&mut instance); + c1767_l1779_action_invoke(&mut instance); + c1768_l1780_action_invoke(&mut instance); + c1769_l1781_action_invoke(&mut instance); + c1770_l1782_action_invoke(&mut instance); + c1771_l1783_action_invoke(&mut instance); + c1772_l1784_action_invoke(&mut instance); + c1773_l1785_action_invoke(&mut instance); + c1774_l1786_action_invoke(&mut instance); + c1775_l1787_action_invoke(&mut instance); + c1776_l1788_action_invoke(&mut instance); + c1777_l1789_action_invoke(&mut instance); + c1778_l1790_action_invoke(&mut instance); + c1779_l1791_action_invoke(&mut instance); + c1780_l1792_action_invoke(&mut instance); + c1781_l1793_action_invoke(&mut instance); + c1782_l1794_action_invoke(&mut instance); + c1783_l1795_action_invoke(&mut instance); + c1784_l1796_action_invoke(&mut instance); + c1785_l1797_action_invoke(&mut instance); + c1786_l1798_action_invoke(&mut instance); + c1787_l1799_action_invoke(&mut instance); + c1788_l1800_action_invoke(&mut instance); + c1789_l1801_action_invoke(&mut instance); + c1790_l1802_action_invoke(&mut instance); + c1791_l1803_action_invoke(&mut instance); + c1792_l1804_action_invoke(&mut instance); + c1793_l1805_action_invoke(&mut instance); + c1794_l1806_action_invoke(&mut instance); + c1795_l1807_action_invoke(&mut instance); + c1796_l1808_action_invoke(&mut instance); + c1797_l1809_action_invoke(&mut instance); + c1798_l1810_action_invoke(&mut instance); + c1799_l1811_action_invoke(&mut instance); + c1800_l1812_action_invoke(&mut instance); + c1801_l1813_action_invoke(&mut instance); + c1802_l1814_action_invoke(&mut instance); + c1803_l1815_action_invoke(&mut instance); + c1804_l1816_action_invoke(&mut instance); + c1805_l1817_action_invoke(&mut instance); + c1806_l1818_action_invoke(&mut instance); + c1807_l1819_action_invoke(&mut instance); + c1808_l1820_action_invoke(&mut instance); + c1809_l1821_action_invoke(&mut instance); + c1810_l1822_action_invoke(&mut instance); + c1811_l1823_action_invoke(&mut instance); + c1812_l1824_action_invoke(&mut instance); + c1813_l1825_action_invoke(&mut instance); + c1814_l1826_action_invoke(&mut instance); + c1815_l1827_action_invoke(&mut instance); + c1816_l1828_action_invoke(&mut instance); + c1817_l1829_action_invoke(&mut instance); + c1818_l1830_action_invoke(&mut instance); + c1819_l1831_action_invoke(&mut instance); + c1820_l1832_action_invoke(&mut instance); + c1821_l1833_action_invoke(&mut instance); + c1822_l1834_action_invoke(&mut instance); + c1823_l1835_action_invoke(&mut instance); + c1824_l1836_action_invoke(&mut instance); + c1825_l1837_action_invoke(&mut instance); + c1826_l1838_action_invoke(&mut instance); + c1827_l1839_action_invoke(&mut instance); + c1828_l1840_action_invoke(&mut instance); + c1829_l1841_action_invoke(&mut instance); + c1830_l1842_action_invoke(&mut instance); + c1831_l1843_action_invoke(&mut instance); + c1832_l1844_action_invoke(&mut instance); + c1833_l1845_action_invoke(&mut instance); + c1834_l1846_action_invoke(&mut instance); + c1835_l1847_action_invoke(&mut instance); + c1836_l1848_action_invoke(&mut instance); + c1837_l1849_action_invoke(&mut instance); + c1838_l1850_action_invoke(&mut instance); + c1839_l1851_action_invoke(&mut instance); + c1840_l1852_action_invoke(&mut instance); + c1841_l1853_action_invoke(&mut instance); + c1842_l1854_action_invoke(&mut instance); + c1843_l1855_action_invoke(&mut instance); + c1844_l1856_action_invoke(&mut instance); + c1845_l1857_action_invoke(&mut instance); + c1846_l1858_action_invoke(&mut instance); + c1847_l1859_action_invoke(&mut instance); + c1848_l1860_action_invoke(&mut instance); + c1849_l1861_action_invoke(&mut instance); + c1850_l1862_action_invoke(&mut instance); + c1851_l1863_action_invoke(&mut instance); + c1852_l1864_action_invoke(&mut instance); + c1853_l1865_action_invoke(&mut instance); + c1854_l1866_action_invoke(&mut instance); + c1855_l1867_action_invoke(&mut instance); + c1856_l1868_action_invoke(&mut instance); + c1857_l1869_action_invoke(&mut instance); + c1858_l1870_action_invoke(&mut instance); + c1859_l1871_action_invoke(&mut instance); + c1860_l1872_action_invoke(&mut instance); + c1861_l1873_action_invoke(&mut instance); + c1862_l1874_action_invoke(&mut instance); + c1863_l1875_action_invoke(&mut instance); + c1864_l1876_action_invoke(&mut instance); + c1865_l1877_action_invoke(&mut instance); + c1866_l1878_action_invoke(&mut instance); + c1867_l1879_action_invoke(&mut instance); + c1868_l1880_action_invoke(&mut instance); + c1869_l1881_action_invoke(&mut instance); + c1870_l1882_action_invoke(&mut instance); + c1871_l1883_action_invoke(&mut instance); + c1872_l1884_action_invoke(&mut instance); + c1873_l1885_action_invoke(&mut instance); + c1874_l1886_action_invoke(&mut instance); + c1875_l1887_action_invoke(&mut instance); + c1876_l1888_action_invoke(&mut instance); + c1877_l1889_action_invoke(&mut instance); + c1878_l1890_action_invoke(&mut instance); + c1879_l1891_action_invoke(&mut instance); + c1880_l1892_action_invoke(&mut instance); + c1881_l1893_action_invoke(&mut instance); + c1882_l1894_action_invoke(&mut instance); + c1883_l1895_action_invoke(&mut instance); + c1884_l1896_action_invoke(&mut instance); + c1885_l1897_action_invoke(&mut instance); + c1886_l1898_action_invoke(&mut instance); + c1887_l1899_action_invoke(&mut instance); + c1888_l1900_action_invoke(&mut instance); + c1889_l1901_action_invoke(&mut instance); + c1890_l1902_action_invoke(&mut instance); + c1891_l1903_action_invoke(&mut instance); + c1892_l1904_action_invoke(&mut instance); + c1893_l1905_action_invoke(&mut instance); + c1894_l1906_action_invoke(&mut instance); + c1895_l1907_action_invoke(&mut instance); + c1896_l1908_action_invoke(&mut instance); + c1897_l1909_action_invoke(&mut instance); + c1898_l1910_action_invoke(&mut instance); + c1899_l1911_action_invoke(&mut instance); + c1900_l1912_action_invoke(&mut instance); + c1901_l1913_action_invoke(&mut instance); + c1902_l1914_action_invoke(&mut instance); + c1903_l1915_action_invoke(&mut instance); + c1904_l1916_action_invoke(&mut instance); + c1905_l1917_action_invoke(&mut instance); + c1906_l1918_action_invoke(&mut instance); + c1907_l1919_action_invoke(&mut instance); + c1908_l1920_action_invoke(&mut instance); + c1909_l1921_action_invoke(&mut instance); + c1910_l1922_action_invoke(&mut instance); + c1911_l1923_action_invoke(&mut instance); + c1912_l1924_action_invoke(&mut instance); + c1913_l1925_action_invoke(&mut instance); + c1914_l1926_action_invoke(&mut instance); + c1915_l1927_action_invoke(&mut instance); + c1916_l1928_action_invoke(&mut instance); + c1917_l1929_action_invoke(&mut instance); + c1918_l1930_action_invoke(&mut instance); + c1919_l1931_action_invoke(&mut instance); + c1920_l1932_action_invoke(&mut instance); + c1921_l1933_action_invoke(&mut instance); + c1922_l1934_action_invoke(&mut instance); + c1923_l1935_action_invoke(&mut instance); + c1924_l1936_action_invoke(&mut instance); + c1925_l1937_action_invoke(&mut instance); + c1926_l1938_action_invoke(&mut instance); + c1927_l1939_action_invoke(&mut instance); + c1928_l1940_action_invoke(&mut instance); + c1929_l1941_action_invoke(&mut instance); + c1930_l1942_action_invoke(&mut instance); + c1931_l1943_action_invoke(&mut instance); + c1932_l1944_action_invoke(&mut instance); + c1933_l1945_action_invoke(&mut instance); + c1934_l1946_action_invoke(&mut instance); + c1935_l1947_action_invoke(&mut instance); + c1936_l1948_action_invoke(&mut instance); + c1937_l1949_action_invoke(&mut instance); + c1938_l1950_action_invoke(&mut instance); + c1939_l1951_action_invoke(&mut instance); + c1940_l1952_action_invoke(&mut instance); + c1941_l1953_action_invoke(&mut instance); + c1942_l1954_action_invoke(&mut instance); + c1943_l1955_action_invoke(&mut instance); + c1944_l1956_action_invoke(&mut instance); + c1945_l1957_action_invoke(&mut instance); + c1946_l1958_action_invoke(&mut instance); + c1947_l1959_action_invoke(&mut instance); + c1948_l1960_action_invoke(&mut instance); + c1949_l1961_action_invoke(&mut instance); + c1950_l1962_action_invoke(&mut instance); + c1951_l1963_action_invoke(&mut instance); + c1952_l1964_action_invoke(&mut instance); + c1953_l1965_action_invoke(&mut instance); + c1954_l1966_action_invoke(&mut instance); + c1955_l1967_action_invoke(&mut instance); + c1956_l1968_action_invoke(&mut instance); + c1957_l1969_action_invoke(&mut instance); + c1958_l1970_action_invoke(&mut instance); + c1959_l1971_action_invoke(&mut instance); + c1960_l1972_action_invoke(&mut instance); + c1961_l1973_action_invoke(&mut instance); + c1962_l1974_action_invoke(&mut instance); + c1963_l1975_action_invoke(&mut instance); + c1964_l1976_action_invoke(&mut instance); + c1965_l1977_action_invoke(&mut instance); + c1966_l1978_action_invoke(&mut instance); + c1967_l1979_action_invoke(&mut instance); + c1968_l1980_action_invoke(&mut instance); + c1969_l1981_action_invoke(&mut instance); + c1970_l1982_action_invoke(&mut instance); + c1971_l1983_action_invoke(&mut instance); + c1972_l1984_action_invoke(&mut instance); + c1973_l1985_action_invoke(&mut instance); + c1974_l1986_action_invoke(&mut instance); + c1975_l1987_action_invoke(&mut instance); + c1976_l1988_action_invoke(&mut instance); + c1977_l1989_action_invoke(&mut instance); + c1978_l1990_action_invoke(&mut instance); + c1979_l1991_action_invoke(&mut instance); + c1980_l1992_action_invoke(&mut instance); + c1981_l1993_action_invoke(&mut instance); + c1982_l1994_action_invoke(&mut instance); + c1983_l1995_action_invoke(&mut instance); + c1984_l1996_action_invoke(&mut instance); + c1985_l1997_action_invoke(&mut instance); + c1986_l1998_action_invoke(&mut instance); + c1987_l1999_action_invoke(&mut instance); + c1988_l2000_action_invoke(&mut instance); + c1989_l2001_action_invoke(&mut instance); + c1990_l2002_action_invoke(&mut instance); + c1991_l2003_action_invoke(&mut instance); + c1992_l2004_action_invoke(&mut instance); + c1993_l2005_action_invoke(&mut instance); + c1994_l2006_action_invoke(&mut instance); + c1995_l2007_action_invoke(&mut instance); + c1996_l2008_action_invoke(&mut instance); + c1997_l2009_action_invoke(&mut instance); + c1998_l2010_action_invoke(&mut instance); + c1999_l2011_action_invoke(&mut instance); + c2000_l2012_action_invoke(&mut instance); + c2001_l2013_action_invoke(&mut instance); + c2002_l2014_action_invoke(&mut instance); + c2003_l2015_action_invoke(&mut instance); + c2004_l2016_action_invoke(&mut instance); + c2005_l2017_action_invoke(&mut instance); + c2006_l2018_action_invoke(&mut instance); + c2007_l2019_action_invoke(&mut instance); + c2008_l2020_action_invoke(&mut instance); + c2009_l2021_action_invoke(&mut instance); + c2010_l2022_action_invoke(&mut instance); + c2011_l2023_action_invoke(&mut instance); + c2012_l2024_action_invoke(&mut instance); + c2013_l2025_action_invoke(&mut instance); + c2014_l2026_action_invoke(&mut instance); + c2015_l2027_action_invoke(&mut instance); + c2016_l2028_action_invoke(&mut instance); + c2017_l2029_action_invoke(&mut instance); + c2018_l2030_action_invoke(&mut instance); + c2019_l2031_action_invoke(&mut instance); + c2020_l2032_action_invoke(&mut instance); + c2021_l2033_action_invoke(&mut instance); + c2022_l2034_action_invoke(&mut instance); + c2023_l2035_action_invoke(&mut instance); + c2024_l2036_action_invoke(&mut instance); + c2025_l2037_action_invoke(&mut instance); + c2026_l2038_action_invoke(&mut instance); + c2027_l2039_action_invoke(&mut instance); + c2028_l2040_action_invoke(&mut instance); + c2029_l2041_action_invoke(&mut instance); + c2030_l2042_action_invoke(&mut instance); + c2031_l2043_action_invoke(&mut instance); + c2032_l2044_action_invoke(&mut instance); + c2033_l2045_action_invoke(&mut instance); + c2034_l2046_action_invoke(&mut instance); + c2035_l2047_action_invoke(&mut instance); + c2036_l2048_action_invoke(&mut instance); + c2037_l2049_action_invoke(&mut instance); + c2038_l2050_action_invoke(&mut instance); + c2039_l2051_action_invoke(&mut instance); + c2040_l2052_action_invoke(&mut instance); + c2041_l2053_action_invoke(&mut instance); + c2042_l2054_action_invoke(&mut instance); + c2043_l2055_action_invoke(&mut instance); + c2044_l2056_action_invoke(&mut instance); + c2045_l2057_action_invoke(&mut instance); + c2046_l2058_action_invoke(&mut instance); + c2047_l2059_action_invoke(&mut instance); + c2048_l2060_action_invoke(&mut instance); + c2049_l2061_action_invoke(&mut instance); + c2050_l2062_action_invoke(&mut instance); + c2051_l2063_action_invoke(&mut instance); + c2052_l2064_action_invoke(&mut instance); + c2053_l2065_action_invoke(&mut instance); + c2054_l2066_action_invoke(&mut instance); + c2055_l2067_action_invoke(&mut instance); + c2056_l2068_action_invoke(&mut instance); + c2057_l2069_action_invoke(&mut instance); + c2058_l2070_action_invoke(&mut instance); + c2059_l2071_action_invoke(&mut instance); + c2060_l2072_action_invoke(&mut instance); + c2061_l2073_action_invoke(&mut instance); + c2062_l2074_action_invoke(&mut instance); + c2063_l2075_action_invoke(&mut instance); + c2064_l2076_action_invoke(&mut instance); + c2065_l2077_action_invoke(&mut instance); + c2066_l2078_action_invoke(&mut instance); + c2067_l2079_action_invoke(&mut instance); + c2068_l2080_action_invoke(&mut instance); + c2069_l2081_action_invoke(&mut instance); + c2070_l2082_action_invoke(&mut instance); + c2071_l2083_action_invoke(&mut instance); + c2072_l2084_action_invoke(&mut instance); + c2073_l2085_action_invoke(&mut instance); + c2074_l2086_action_invoke(&mut instance); + c2075_l2087_action_invoke(&mut instance); + c2076_l2088_action_invoke(&mut instance); + c2077_l2089_action_invoke(&mut instance); + c2078_l2090_action_invoke(&mut instance); + c2079_l2091_action_invoke(&mut instance); + c2080_l2092_action_invoke(&mut instance); + c2081_l2093_action_invoke(&mut instance); + c2082_l2094_action_invoke(&mut instance); + c2083_l2095_action_invoke(&mut instance); + c2084_l2096_action_invoke(&mut instance); + c2085_l2097_action_invoke(&mut instance); + c2086_l2098_action_invoke(&mut instance); + c2087_l2099_action_invoke(&mut instance); + c2088_l2100_action_invoke(&mut instance); + c2089_l2101_action_invoke(&mut instance); + c2090_l2102_action_invoke(&mut instance); + c2091_l2103_action_invoke(&mut instance); + c2092_l2104_action_invoke(&mut instance); + c2093_l2105_action_invoke(&mut instance); + c2094_l2106_action_invoke(&mut instance); + c2095_l2107_action_invoke(&mut instance); + c2096_l2108_action_invoke(&mut instance); + c2097_l2109_action_invoke(&mut instance); + c2098_l2110_action_invoke(&mut instance); + c2099_l2111_action_invoke(&mut instance); + c2100_l2112_action_invoke(&mut instance); + c2101_l2113_action_invoke(&mut instance); + c2102_l2114_action_invoke(&mut instance); + c2103_l2115_action_invoke(&mut instance); + c2104_l2116_action_invoke(&mut instance); + c2105_l2117_action_invoke(&mut instance); + c2106_l2118_action_invoke(&mut instance); + c2107_l2119_action_invoke(&mut instance); + c2108_l2120_action_invoke(&mut instance); + c2109_l2121_action_invoke(&mut instance); + c2110_l2122_action_invoke(&mut instance); + c2111_l2123_action_invoke(&mut instance); + c2112_l2124_action_invoke(&mut instance); + c2113_l2125_action_invoke(&mut instance); + c2114_l2126_action_invoke(&mut instance); + c2115_l2127_action_invoke(&mut instance); + c2116_l2128_action_invoke(&mut instance); + c2117_l2129_action_invoke(&mut instance); + c2118_l2130_action_invoke(&mut instance); + c2119_l2131_action_invoke(&mut instance); + c2120_l2132_action_invoke(&mut instance); + c2121_l2133_action_invoke(&mut instance); + c2122_l2134_action_invoke(&mut instance); + c2123_l2135_action_invoke(&mut instance); + c2124_l2136_action_invoke(&mut instance); + c2125_l2137_action_invoke(&mut instance); + c2126_l2138_action_invoke(&mut instance); + c2127_l2139_action_invoke(&mut instance); + c2128_l2140_action_invoke(&mut instance); + c2129_l2141_action_invoke(&mut instance); + c2130_l2142_action_invoke(&mut instance); + c2131_l2143_action_invoke(&mut instance); + c2132_l2144_action_invoke(&mut instance); + c2133_l2145_action_invoke(&mut instance); + c2134_l2146_action_invoke(&mut instance); + c2135_l2147_action_invoke(&mut instance); + c2136_l2148_action_invoke(&mut instance); + c2137_l2149_action_invoke(&mut instance); + c2138_l2150_action_invoke(&mut instance); + c2139_l2151_action_invoke(&mut instance); + c2140_l2152_action_invoke(&mut instance); + c2141_l2153_action_invoke(&mut instance); + c2142_l2154_action_invoke(&mut instance); + c2143_l2155_action_invoke(&mut instance); + c2144_l2156_action_invoke(&mut instance); + c2145_l2157_action_invoke(&mut instance); + c2146_l2158_action_invoke(&mut instance); + c2147_l2159_action_invoke(&mut instance); + c2148_l2160_action_invoke(&mut instance); + c2149_l2161_action_invoke(&mut instance); + c2150_l2162_action_invoke(&mut instance); + c2151_l2163_action_invoke(&mut instance); + c2152_l2164_action_invoke(&mut instance); + c2153_l2165_action_invoke(&mut instance); + c2154_l2166_action_invoke(&mut instance); + c2155_l2167_action_invoke(&mut instance); + c2156_l2168_action_invoke(&mut instance); + c2157_l2169_action_invoke(&mut instance); + c2158_l2170_action_invoke(&mut instance); + c2159_l2171_action_invoke(&mut instance); + c2160_l2172_action_invoke(&mut instance); + c2161_l2173_action_invoke(&mut instance); + c2162_l2174_action_invoke(&mut instance); + c2163_l2175_action_invoke(&mut instance); + c2164_l2176_action_invoke(&mut instance); + c2165_l2177_action_invoke(&mut instance); + c2166_l2178_action_invoke(&mut instance); + c2167_l2179_action_invoke(&mut instance); + c2168_l2180_action_invoke(&mut instance); + c2169_l2181_action_invoke(&mut instance); + c2170_l2182_action_invoke(&mut instance); + c2171_l2183_action_invoke(&mut instance); + c2172_l2184_action_invoke(&mut instance); + c2173_l2185_action_invoke(&mut instance); + c2174_l2186_action_invoke(&mut instance); + c2175_l2187_action_invoke(&mut instance); + c2176_l2188_action_invoke(&mut instance); + c2177_l2189_action_invoke(&mut instance); + c2178_l2190_action_invoke(&mut instance); + c2179_l2191_action_invoke(&mut instance); + c2180_l2192_action_invoke(&mut instance); + c2181_l2193_action_invoke(&mut instance); + c2182_l2194_action_invoke(&mut instance); + c2183_l2195_action_invoke(&mut instance); + c2184_l2196_action_invoke(&mut instance); + c2185_l2197_action_invoke(&mut instance); + c2186_l2198_action_invoke(&mut instance); + c2187_l2199_action_invoke(&mut instance); + c2188_l2200_action_invoke(&mut instance); + c2189_l2201_action_invoke(&mut instance); + c2190_l2202_action_invoke(&mut instance); + c2191_l2203_action_invoke(&mut instance); + c2192_l2204_action_invoke(&mut instance); + c2193_l2205_action_invoke(&mut instance); + c2194_l2206_action_invoke(&mut instance); + c2195_l2207_action_invoke(&mut instance); + c2196_l2208_action_invoke(&mut instance); + c2197_l2209_action_invoke(&mut instance); + c2198_l2210_action_invoke(&mut instance); + c2199_l2211_action_invoke(&mut instance); + c2200_l2212_action_invoke(&mut instance); + c2201_l2213_action_invoke(&mut instance); + c2202_l2214_action_invoke(&mut instance); + c2203_l2215_action_invoke(&mut instance); + c2204_l2216_action_invoke(&mut instance); + c2205_l2217_action_invoke(&mut instance); + c2206_l2218_action_invoke(&mut instance); + c2207_l2219_action_invoke(&mut instance); + c2208_l2220_action_invoke(&mut instance); + c2209_l2221_action_invoke(&mut instance); + c2210_l2222_action_invoke(&mut instance); + c2211_l2223_action_invoke(&mut instance); + c2212_l2224_action_invoke(&mut instance); + c2213_l2225_action_invoke(&mut instance); + c2214_l2226_action_invoke(&mut instance); + c2215_l2227_action_invoke(&mut instance); + c2216_l2228_action_invoke(&mut instance); + c2217_l2229_action_invoke(&mut instance); + c2218_l2230_action_invoke(&mut instance); + c2219_l2231_action_invoke(&mut instance); + c2220_l2232_action_invoke(&mut instance); + c2221_l2233_action_invoke(&mut instance); + c2222_l2234_action_invoke(&mut instance); + c2223_l2235_action_invoke(&mut instance); + c2224_l2236_action_invoke(&mut instance); + c2225_l2237_action_invoke(&mut instance); + c2226_l2238_action_invoke(&mut instance); + c2227_l2239_action_invoke(&mut instance); + c2228_l2240_action_invoke(&mut instance); + c2229_l2241_action_invoke(&mut instance); + c2230_l2242_action_invoke(&mut instance); + c2231_l2243_action_invoke(&mut instance); + c2232_l2244_action_invoke(&mut instance); + c2233_l2245_action_invoke(&mut instance); + c2234_l2246_action_invoke(&mut instance); + c2235_l2247_action_invoke(&mut instance); + c2236_l2248_action_invoke(&mut instance); + c2237_l2249_action_invoke(&mut instance); + c2238_l2250_action_invoke(&mut instance); + c2239_l2251_action_invoke(&mut instance); + c2240_l2252_action_invoke(&mut instance); + c2241_l2253_action_invoke(&mut instance); + c2242_l2254_action_invoke(&mut instance); + c2243_l2255_action_invoke(&mut instance); + c2244_l2256_action_invoke(&mut instance); + c2245_l2257_action_invoke(&mut instance); + c2246_l2258_action_invoke(&mut instance); + c2247_l2259_action_invoke(&mut instance); + c2248_l2260_action_invoke(&mut instance); + c2249_l2261_action_invoke(&mut instance); + c2250_l2262_action_invoke(&mut instance); + c2251_l2263_action_invoke(&mut instance); + c2252_l2264_action_invoke(&mut instance); + c2253_l2265_action_invoke(&mut instance); + c2254_l2266_action_invoke(&mut instance); + c2255_l2267_action_invoke(&mut instance); + c2256_l2268_action_invoke(&mut instance); + c2257_l2269_action_invoke(&mut instance); + c2258_l2270_action_invoke(&mut instance); + c2259_l2271_action_invoke(&mut instance); + c2260_l2272_action_invoke(&mut instance); + c2261_l2273_action_invoke(&mut instance); + c2262_l2274_action_invoke(&mut instance); + c2263_l2275_action_invoke(&mut instance); + c2264_l2276_action_invoke(&mut instance); + c2265_l2277_action_invoke(&mut instance); + c2266_l2278_action_invoke(&mut instance); + c2267_l2279_action_invoke(&mut instance); + c2268_l2280_action_invoke(&mut instance); + c2269_l2281_action_invoke(&mut instance); + c2270_l2282_action_invoke(&mut instance); + c2271_l2283_action_invoke(&mut instance); + c2272_l2284_action_invoke(&mut instance); + c2273_l2285_action_invoke(&mut instance); + c2274_l2286_action_invoke(&mut instance); + c2275_l2287_action_invoke(&mut instance); + c2276_l2288_action_invoke(&mut instance); + c2277_l2289_action_invoke(&mut instance); + c2278_l2290_action_invoke(&mut instance); + c2279_l2291_action_invoke(&mut instance); + c2280_l2292_action_invoke(&mut instance); + c2281_l2293_action_invoke(&mut instance); + c2282_l2294_action_invoke(&mut instance); + c2283_l2295_action_invoke(&mut instance); + c2284_l2296_action_invoke(&mut instance); + c2285_l2297_action_invoke(&mut instance); + c2286_l2298_action_invoke(&mut instance); + c2287_l2299_action_invoke(&mut instance); + c2288_l2300_action_invoke(&mut instance); + c2289_l2301_action_invoke(&mut instance); + c2290_l2302_action_invoke(&mut instance); + c2291_l2303_action_invoke(&mut instance); + c2292_l2304_action_invoke(&mut instance); + c2293_l2305_action_invoke(&mut instance); + c2294_l2306_action_invoke(&mut instance); + c2295_l2307_action_invoke(&mut instance); + c2296_l2308_action_invoke(&mut instance); + c2297_l2309_action_invoke(&mut instance); + c2298_l2310_action_invoke(&mut instance); + c2299_l2311_action_invoke(&mut instance); + c2300_l2312_action_invoke(&mut instance); + c2301_l2313_action_invoke(&mut instance); + c2302_l2314_action_invoke(&mut instance); + c2303_l2315_action_invoke(&mut instance); + c2304_l2316_action_invoke(&mut instance); + c2305_l2317_action_invoke(&mut instance); + c2306_l2318_action_invoke(&mut instance); + c2307_l2319_action_invoke(&mut instance); + c2308_l2320_action_invoke(&mut instance); + c2309_l2321_action_invoke(&mut instance); + c2310_l2322_action_invoke(&mut instance); + c2311_l2323_action_invoke(&mut instance); + c2312_l2324_action_invoke(&mut instance); + c2313_l2325_action_invoke(&mut instance); + c2314_l2326_action_invoke(&mut instance); + c2315_l2327_action_invoke(&mut instance); + c2316_l2328_action_invoke(&mut instance); + c2317_l2329_action_invoke(&mut instance); + c2318_l2330_action_invoke(&mut instance); + c2319_l2331_action_invoke(&mut instance); + c2320_l2332_action_invoke(&mut instance); + c2321_l2333_action_invoke(&mut instance); + c2322_l2334_action_invoke(&mut instance); + c2323_l2335_action_invoke(&mut instance); + c2324_l2336_action_invoke(&mut instance); + c2325_l2337_action_invoke(&mut instance); + c2326_l2338_action_invoke(&mut instance); + c2327_l2339_action_invoke(&mut instance); + c2328_l2340_action_invoke(&mut instance); + c2329_l2341_action_invoke(&mut instance); + c2330_l2342_action_invoke(&mut instance); + c2331_l2343_action_invoke(&mut instance); + c2332_l2344_action_invoke(&mut instance); + c2333_l2345_action_invoke(&mut instance); + c2334_l2346_action_invoke(&mut instance); + c2335_l2347_action_invoke(&mut instance); + c2336_l2348_action_invoke(&mut instance); + c2337_l2349_action_invoke(&mut instance); + c2338_l2350_action_invoke(&mut instance); + c2339_l2351_action_invoke(&mut instance); + c2340_l2352_action_invoke(&mut instance); + c2341_l2353_action_invoke(&mut instance); + c2342_l2354_action_invoke(&mut instance); + c2343_l2355_action_invoke(&mut instance); + c2344_l2356_action_invoke(&mut instance); + c2345_l2357_action_invoke(&mut instance); + c2346_l2358_action_invoke(&mut instance); + c2347_l2359_action_invoke(&mut instance); + c2348_l2360_action_invoke(&mut instance); + c2349_l2361_action_invoke(&mut instance); + c2350_l2362_action_invoke(&mut instance); + c2351_l2363_action_invoke(&mut instance); + c2352_l2364_action_invoke(&mut instance); + c2353_l2365_action_invoke(&mut instance); + c2354_l2366_action_invoke(&mut instance); + c2355_l2367_action_invoke(&mut instance); + c2356_l2368_action_invoke(&mut instance); + c2357_l2369_action_invoke(&mut instance); + c2358_l2370_action_invoke(&mut instance); + c2359_l2371_action_invoke(&mut instance); + c2360_l2372_action_invoke(&mut instance); + c2361_l2373_action_invoke(&mut instance); + c2362_l2374_action_invoke(&mut instance); + c2363_l2375_action_invoke(&mut instance); + c2364_l2376_action_invoke(&mut instance); + c2365_l2377_action_invoke(&mut instance); + c2366_l2378_action_invoke(&mut instance); + c2367_l2379_action_invoke(&mut instance); + c2368_l2380_action_invoke(&mut instance); + c2369_l2381_action_invoke(&mut instance); + c2370_l2382_action_invoke(&mut instance); + c2371_l2383_action_invoke(&mut instance); + c2372_l2384_action_invoke(&mut instance); + c2373_l2385_action_invoke(&mut instance); + c2374_l2386_action_invoke(&mut instance); + c2375_l2387_action_invoke(&mut instance); + c2376_l2388_action_invoke(&mut instance); + c2377_l2389_action_invoke(&mut instance); + c2378_l2390_action_invoke(&mut instance); + c2379_l2391_action_invoke(&mut instance); + c2380_l2392_action_invoke(&mut instance); + c2381_l2393_action_invoke(&mut instance); + c2382_l2394_action_invoke(&mut instance); + c2383_l2395_action_invoke(&mut instance); + c2384_l2396_action_invoke(&mut instance); + c2385_l2397_action_invoke(&mut instance); + c2386_l2398_action_invoke(&mut instance); + c2387_l2399_action_invoke(&mut instance); + c2388_l2400_action_invoke(&mut instance); + c2389_l2401_action_invoke(&mut instance); + c2390_l2402_action_invoke(&mut instance); + c2391_l2403_action_invoke(&mut instance); + c2392_l2404_action_invoke(&mut instance); + c2393_l2405_action_invoke(&mut instance); + c2394_l2406_action_invoke(&mut instance); + c2395_l2407_action_invoke(&mut instance); + c2396_l2408_action_invoke(&mut instance); + c2397_l2409_action_invoke(&mut instance); + c2398_l2410_action_invoke(&mut instance); + c2399_l2411_action_invoke(&mut instance); + c2400_l2412_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/f64_.rs b/lib/runtime/tests/spectests/f64_.rs new file mode 100644 index 000000000..d69188c7d --- /dev/null +++ b/lib/runtime/tests/spectests/f64_.rs @@ -0,0 +1,25325 @@ +// 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/f64_.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 5 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func (param f64 f64) (result f64))) + (type (;1;) (func (param f64) (result f64))) + (func (;0;) (type 0) (param f64 f64) (result f64) + get_local 0 + get_local 1 + f64.add) + (func (;1;) (type 0) (param f64 f64) (result f64) + get_local 0 + get_local 1 + f64.sub) + (func (;2;) (type 0) (param f64 f64) (result f64) + get_local 0 + get_local 1 + f64.mul) + (func (;3;) (type 0) (param f64 f64) (result f64) + get_local 0 + get_local 1 + f64.div) + (func (;4;) (type 1) (param f64) (result f64) + get_local 0 + f64.sqrt) + (func (;5;) (type 0) (param f64 f64) (result f64) + get_local 0 + get_local 1 + f64.min) + (func (;6;) (type 0) (param f64 f64) (result f64) + get_local 0 + get_local 1 + f64.max) + (func (;7;) (type 1) (param f64) (result f64) + get_local 0 + f64.ceil) + (func (;8;) (type 1) (param f64) (result f64) + get_local 0 + f64.floor) + (func (;9;) (type 1) (param f64) (result f64) + get_local 0 + f64.trunc) + (func (;10;) (type 1) (param f64) (result f64) + get_local 0 + f64.nearest) + (export \"add\" (func 0)) + (export \"sub\" (func 1)) + (export \"mul\" (func 2)) + (export \"div\" (func 3)) + (export \"sqrt\" (func 4)) + (export \"min\" (func 5)) + (export \"max\" (func 6)) + (export \"ceil\" (func 7)) + (export \"floor\" (func 8)) + (export \"trunc\" (func 9)) + (export \"nearest\" (func 10))) + "; + 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 19 +fn c1_l19_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l19_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 20 +fn c2_l20_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l20_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 21 +fn c3_l21_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l21_action_invoke"); + let result = instance.call("add", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 22 +fn c4_l22_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l22_action_invoke"); + let result = instance.call("add", &[Value::F64((0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 23 +fn c5_l23_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l23_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 24 +fn c6_l24_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l24_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 25 +fn c7_l25_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l25_action_invoke"); + let result = instance.call("add", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 26 +fn c8_l26_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l26_action_invoke"); + let result = instance.call("add", &[Value::F64((0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 27 +fn c9_l27_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l27_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 28 +fn c10_l28_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c10_l28_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 29 +fn c11_l29_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c11_l29_action_invoke"); + let result = instance.call("add", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 30 +fn c12_l30_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c12_l30_action_invoke"); + let result = instance.call("add", &[Value::F64((0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 31 +fn c13_l31_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c13_l31_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 32 +fn c14_l32_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c14_l32_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 33 +fn c15_l33_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c15_l33_action_invoke"); + let result = instance.call("add", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 34 +fn c16_l34_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c16_l34_action_invoke"); + let result = instance.call("add", &[Value::F64((0.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 35 +fn c17_l35_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c17_l35_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 36 +fn c18_l36_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c18_l36_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 37 +fn c19_l37_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c19_l37_action_invoke"); + let result = instance.call("add", &[Value::F64((0.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 38 +fn c20_l38_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c20_l38_action_invoke"); + let result = instance.call("add", &[Value::F64((0.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 39 +fn c21_l39_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c21_l39_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 40 +fn c22_l40_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c22_l40_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 41 +fn c23_l41_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c23_l41_action_invoke"); + let result = instance.call("add", &[Value::F64((0.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 42 +fn c24_l42_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c24_l42_action_invoke"); + let result = instance.call("add", &[Value::F64((0.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 43 +fn c25_l43_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c25_l43_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 44 +fn c26_l44_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c26_l44_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 45 +fn c27_l45_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c27_l45_action_invoke"); + let result = instance.call("add", &[Value::F64((0.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 46 +fn c28_l46_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c28_l46_action_invoke"); + let result = instance.call("add", &[Value::F64((0.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 47 +fn c29_l47_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c29_l47_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 48 +fn c30_l48_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c30_l48_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 49 +fn c31_l49_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c31_l49_action_invoke"); + let result = instance.call("add", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 50 +fn c32_l50_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c32_l50_action_invoke"); + let result = instance.call("add", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 51 +fn c33_l51_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c33_l51_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c33_l51_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 52 +fn c34_l52_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c34_l52_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c34_l52_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 53 +fn c35_l53_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c35_l53_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c35_l53_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 54 +fn c36_l54_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c36_l54_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c36_l54_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 55 +fn c37_l55_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c37_l55_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c37_l55_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 56 +fn c38_l56_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c38_l56_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c38_l56_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 57 +fn c39_l57_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c39_l57_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c39_l57_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 58 +fn c40_l58_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c40_l58_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c40_l58_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 59 +fn c41_l59_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c41_l59_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 60 +fn c42_l60_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c42_l60_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 61 +fn c43_l61_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c43_l61_action_invoke"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 62 +fn c44_l62_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c44_l62_action_invoke"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 63 +fn c45_l63_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c45_l63_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001f64).to_bits())))); + result.map(|_| ()) +} + +// Line 64 +fn c46_l64_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c46_l64_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 65 +fn c47_l65_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c47_l65_action_invoke"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 66 +fn c48_l66_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c48_l66_action_invoke"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001f64).to_bits())))); + result.map(|_| ()) +} + +// Line 67 +fn c49_l67_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c49_l67_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507202f64).to_bits())))); + result.map(|_| ()) +} + +// Line 68 +fn c50_l68_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c50_l68_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201f64).to_bits())))); + result.map(|_| ()) +} + +// Line 69 +fn c51_l69_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c51_l69_action_invoke"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201f64).to_bits())))); + result.map(|_| ()) +} + +// Line 70 +fn c52_l70_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c52_l70_action_invoke"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507202f64).to_bits())))); + result.map(|_| ()) +} + +// Line 71 +fn c53_l71_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c53_l71_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 72 +fn c54_l72_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c54_l72_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 73 +fn c55_l73_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c55_l73_action_invoke"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 74 +fn c56_l74_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c56_l74_action_invoke"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 75 +fn c57_l75_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c57_l75_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 76 +fn c58_l76_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c58_l76_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 77 +fn c59_l77_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c59_l77_action_invoke"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 78 +fn c60_l78_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c60_l78_action_invoke"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 79 +fn c61_l79_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c61_l79_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 80 +fn c62_l80_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c62_l80_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 81 +fn c63_l81_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c63_l81_action_invoke"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 82 +fn c64_l82_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c64_l82_action_invoke"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 83 +fn c65_l83_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c65_l83_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 84 +fn c66_l84_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c66_l84_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 85 +fn c67_l85_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c67_l85_action_invoke"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 86 +fn c68_l86_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c68_l86_action_invoke"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 87 +fn c69_l87_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c69_l87_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 88 +fn c70_l88_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c70_l88_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 89 +fn c71_l89_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c71_l89_action_invoke"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 90 +fn c72_l90_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c72_l90_action_invoke"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 91 +fn c73_l91_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c73_l91_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c73_l91_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 92 +fn c74_l92_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c74_l92_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c74_l92_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 93 +fn c75_l93_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c75_l93_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c75_l93_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 94 +fn c76_l94_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c76_l94_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c76_l94_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 95 +fn c77_l95_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c77_l95_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c77_l95_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 96 +fn c78_l96_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c78_l96_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c78_l96_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 97 +fn c79_l97_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c79_l97_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c79_l97_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 98 +fn c80_l98_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c80_l98_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c80_l98_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 99 +fn c81_l99_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c81_l99_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 100 +fn c82_l100_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c82_l100_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 101 +fn c83_l101_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c83_l101_action_invoke"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 102 +fn c84_l102_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c84_l102_action_invoke"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 103 +fn c85_l103_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c85_l103_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507202f64).to_bits())))); + result.map(|_| ()) +} + +// Line 104 +fn c86_l104_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c86_l104_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201f64).to_bits())))); + result.map(|_| ()) +} + +// Line 105 +fn c87_l105_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c87_l105_action_invoke"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201f64).to_bits())))); + result.map(|_| ()) +} + +// Line 106 +fn c88_l106_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c88_l106_action_invoke"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507202f64).to_bits())))); + result.map(|_| ()) +} + +// Line 107 +fn c89_l107_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c89_l107_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004450147717014403f64).to_bits())))); + result.map(|_| ()) +} + +// Line 108 +fn c90_l108_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c90_l108_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 109 +fn c91_l109_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c91_l109_action_invoke"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 110 +fn c92_l110_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c92_l110_action_invoke"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004450147717014403f64).to_bits())))); + result.map(|_| ()) +} + +// Line 111 +fn c93_l111_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c93_l111_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 112 +fn c94_l112_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c94_l112_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 113 +fn c95_l113_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c95_l113_action_invoke"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 114 +fn c96_l114_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c96_l114_action_invoke"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 115 +fn c97_l115_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c97_l115_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 116 +fn c98_l116_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c98_l116_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 117 +fn c99_l117_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c99_l117_action_invoke"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 118 +fn c100_l118_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c100_l118_action_invoke"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 119 +fn c101_l119_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c101_l119_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 120 +fn c102_l120_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c102_l120_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 121 +fn c103_l121_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c103_l121_action_invoke"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 122 +fn c104_l122_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c104_l122_action_invoke"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 123 +fn c105_l123_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c105_l123_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 124 +fn c106_l124_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c106_l124_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 125 +fn c107_l125_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c107_l125_action_invoke"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 126 +fn c108_l126_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c108_l126_action_invoke"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 127 +fn c109_l127_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c109_l127_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 128 +fn c110_l128_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c110_l128_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 129 +fn c111_l129_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c111_l129_action_invoke"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 130 +fn c112_l130_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c112_l130_action_invoke"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 131 +fn c113_l131_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c113_l131_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c113_l131_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 132 +fn c114_l132_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c114_l132_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c114_l132_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 133 +fn c115_l133_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c115_l133_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c115_l133_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 134 +fn c116_l134_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c116_l134_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c116_l134_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 135 +fn c117_l135_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c117_l135_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c117_l135_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 136 +fn c118_l136_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c118_l136_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c118_l136_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 137 +fn c119_l137_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c119_l137_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c119_l137_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 138 +fn c120_l138_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c120_l138_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c120_l138_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 139 +fn c121_l139_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c121_l139_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 140 +fn c122_l140_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c122_l140_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 141 +fn c123_l141_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c123_l141_action_invoke"); + let result = instance.call("add", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 142 +fn c124_l142_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c124_l142_action_invoke"); + let result = instance.call("add", &[Value::F64((0.5f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 143 +fn c125_l143_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c125_l143_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 144 +fn c126_l144_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c126_l144_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 145 +fn c127_l145_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c127_l145_action_invoke"); + let result = instance.call("add", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 146 +fn c128_l146_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c128_l146_action_invoke"); + let result = instance.call("add", &[Value::F64((0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 147 +fn c129_l147_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c129_l147_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 148 +fn c130_l148_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c130_l148_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 149 +fn c131_l149_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c131_l149_action_invoke"); + let result = instance.call("add", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 150 +fn c132_l150_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c132_l150_action_invoke"); + let result = instance.call("add", &[Value::F64((0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 151 +fn c133_l151_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c133_l151_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 152 +fn c134_l152_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c134_l152_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 153 +fn c135_l153_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c135_l153_action_invoke"); + let result = instance.call("add", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 154 +fn c136_l154_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c136_l154_action_invoke"); + let result = instance.call("add", &[Value::F64((0.5f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 155 +fn c137_l155_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c137_l155_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.5f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 156 +fn c138_l156_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c138_l156_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.5f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 157 +fn c139_l157_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c139_l157_action_invoke"); + let result = instance.call("add", &[Value::F64((0.5f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 158 +fn c140_l158_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c140_l158_action_invoke"); + let result = instance.call("add", &[Value::F64((0.5f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 159 +fn c141_l159_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c141_l159_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.5f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.783185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 160 +fn c142_l160_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c142_l160_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.5f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((5.783185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 161 +fn c143_l161_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c143_l161_action_invoke"); + let result = instance.call("add", &[Value::F64((0.5f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-5.783185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 162 +fn c144_l162_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c144_l162_action_invoke"); + let result = instance.call("add", &[Value::F64((0.5f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.783185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 163 +fn c145_l163_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c145_l163_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.5f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 164 +fn c146_l164_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c146_l164_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.5f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 165 +fn c147_l165_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c147_l165_action_invoke"); + let result = instance.call("add", &[Value::F64((0.5f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 166 +fn c148_l166_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c148_l166_action_invoke"); + let result = instance.call("add", &[Value::F64((0.5f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 167 +fn c149_l167_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c149_l167_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 168 +fn c150_l168_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c150_l168_action_invoke"); + let result = instance.call("add", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 169 +fn c151_l169_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c151_l169_action_invoke"); + let result = instance.call("add", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 170 +fn c152_l170_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c152_l170_action_invoke"); + let result = instance.call("add", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 171 +fn c153_l171_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c153_l171_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c153_l171_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 172 +fn c154_l172_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c154_l172_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c154_l172_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 173 +fn c155_l173_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c155_l173_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c155_l173_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 174 +fn c156_l174_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c156_l174_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c156_l174_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 175 +fn c157_l175_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c157_l175_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c157_l175_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 176 +fn c158_l176_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c158_l176_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c158_l176_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 177 +fn c159_l177_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c159_l177_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c159_l177_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 178 +fn c160_l178_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c160_l178_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c160_l178_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 179 +fn c161_l179_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c161_l179_action_invoke"); + let result = instance.call("add", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 180 +fn c162_l180_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c162_l180_action_invoke"); + let result = instance.call("add", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 181 +fn c163_l181_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c163_l181_action_invoke"); + let result = instance.call("add", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 182 +fn c164_l182_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c164_l182_action_invoke"); + let result = instance.call("add", &[Value::F64((1.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 183 +fn c165_l183_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c165_l183_action_invoke"); + let result = instance.call("add", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 184 +fn c166_l184_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c166_l184_action_invoke"); + let result = instance.call("add", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 185 +fn c167_l185_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c167_l185_action_invoke"); + let result = instance.call("add", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 186 +fn c168_l186_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c168_l186_action_invoke"); + let result = instance.call("add", &[Value::F64((1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 187 +fn c169_l187_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c169_l187_action_invoke"); + let result = instance.call("add", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 188 +fn c170_l188_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c170_l188_action_invoke"); + let result = instance.call("add", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 189 +fn c171_l189_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c171_l189_action_invoke"); + let result = instance.call("add", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 190 +fn c172_l190_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c172_l190_action_invoke"); + let result = instance.call("add", &[Value::F64((1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 191 +fn c173_l191_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c173_l191_action_invoke"); + let result = instance.call("add", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 192 +fn c174_l192_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c174_l192_action_invoke"); + let result = instance.call("add", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 193 +fn c175_l193_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c175_l193_action_invoke"); + let result = instance.call("add", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 194 +fn c176_l194_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c176_l194_action_invoke"); + let result = instance.call("add", &[Value::F64((1.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 195 +fn c177_l195_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c177_l195_action_invoke"); + let result = instance.call("add", &[Value::F64((-1.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-2.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 196 +fn c178_l196_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c178_l196_action_invoke"); + let result = instance.call("add", &[Value::F64((-1.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 197 +fn c179_l197_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c179_l197_action_invoke"); + let result = instance.call("add", &[Value::F64((1.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 198 +fn c180_l198_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c180_l198_action_invoke"); + let result = instance.call("add", &[Value::F64((1.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((2.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 199 +fn c181_l199_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c181_l199_action_invoke"); + let result = instance.call("add", &[Value::F64((-1.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-7.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 200 +fn c182_l200_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c182_l200_action_invoke"); + let result = instance.call("add", &[Value::F64((-1.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((5.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 201 +fn c183_l201_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c183_l201_action_invoke"); + let result = instance.call("add", &[Value::F64((1.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-5.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 202 +fn c184_l202_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c184_l202_action_invoke"); + let result = instance.call("add", &[Value::F64((1.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((7.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 203 +fn c185_l203_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c185_l203_action_invoke"); + let result = instance.call("add", &[Value::F64((-1.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 204 +fn c186_l204_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c186_l204_action_invoke"); + let result = instance.call("add", &[Value::F64((-1.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 205 +fn c187_l205_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c187_l205_action_invoke"); + let result = instance.call("add", &[Value::F64((1.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 206 +fn c188_l206_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c188_l206_action_invoke"); + let result = instance.call("add", &[Value::F64((1.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 207 +fn c189_l207_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c189_l207_action_invoke"); + let result = instance.call("add", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 208 +fn c190_l208_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c190_l208_action_invoke"); + let result = instance.call("add", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 209 +fn c191_l209_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c191_l209_action_invoke"); + let result = instance.call("add", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 210 +fn c192_l210_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c192_l210_action_invoke"); + let result = instance.call("add", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 211 +fn c193_l211_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c193_l211_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c193_l211_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 212 +fn c194_l212_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c194_l212_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c194_l212_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 213 +fn c195_l213_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c195_l213_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c195_l213_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 214 +fn c196_l214_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c196_l214_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c196_l214_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 215 +fn c197_l215_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c197_l215_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c197_l215_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 216 +fn c198_l216_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c198_l216_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c198_l216_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 217 +fn c199_l217_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c199_l217_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c199_l217_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 218 +fn c200_l218_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c200_l218_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c200_l218_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 219 +fn c201_l219_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c201_l219_action_invoke"); + let result = instance.call("add", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 220 +fn c202_l220_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c202_l220_action_invoke"); + let result = instance.call("add", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 221 +fn c203_l221_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c203_l221_action_invoke"); + let result = instance.call("add", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 222 +fn c204_l222_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c204_l222_action_invoke"); + let result = instance.call("add", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 223 +fn c205_l223_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c205_l223_action_invoke"); + let result = instance.call("add", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 224 +fn c206_l224_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c206_l224_action_invoke"); + let result = instance.call("add", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 225 +fn c207_l225_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c207_l225_action_invoke"); + let result = instance.call("add", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 226 +fn c208_l226_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c208_l226_action_invoke"); + let result = instance.call("add", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 227 +fn c209_l227_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c209_l227_action_invoke"); + let result = instance.call("add", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 228 +fn c210_l228_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c210_l228_action_invoke"); + let result = instance.call("add", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 229 +fn c211_l229_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c211_l229_action_invoke"); + let result = instance.call("add", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 230 +fn c212_l230_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c212_l230_action_invoke"); + let result = instance.call("add", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 231 +fn c213_l231_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c213_l231_action_invoke"); + let result = instance.call("add", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.783185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 232 +fn c214_l232_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c214_l232_action_invoke"); + let result = instance.call("add", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-5.783185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 233 +fn c215_l233_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c215_l233_action_invoke"); + let result = instance.call("add", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((5.783185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 234 +fn c216_l234_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c216_l234_action_invoke"); + let result = instance.call("add", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.783185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 235 +fn c217_l235_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c217_l235_action_invoke"); + let result = instance.call("add", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-7.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 236 +fn c218_l236_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c218_l236_action_invoke"); + let result = instance.call("add", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-5.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 237 +fn c219_l237_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c219_l237_action_invoke"); + let result = instance.call("add", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((5.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 238 +fn c220_l238_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c220_l238_action_invoke"); + let result = instance.call("add", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((7.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 239 +fn c221_l239_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c221_l239_action_invoke"); + let result = instance.call("add", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-12.566370614359172f64).to_bits())))); + result.map(|_| ()) +} + +// Line 240 +fn c222_l240_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c222_l240_action_invoke"); + let result = instance.call("add", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 241 +fn c223_l241_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c223_l241_action_invoke"); + let result = instance.call("add", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 242 +fn c224_l242_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c224_l242_action_invoke"); + let result = instance.call("add", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((12.566370614359172f64).to_bits())))); + result.map(|_| ()) +} + +// Line 243 +fn c225_l243_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c225_l243_action_invoke"); + let result = instance.call("add", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 244 +fn c226_l244_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c226_l244_action_invoke"); + let result = instance.call("add", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 245 +fn c227_l245_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c227_l245_action_invoke"); + let result = instance.call("add", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 246 +fn c228_l246_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c228_l246_action_invoke"); + let result = instance.call("add", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 247 +fn c229_l247_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c229_l247_action_invoke"); + let result = instance.call("add", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 248 +fn c230_l248_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c230_l248_action_invoke"); + let result = instance.call("add", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 249 +fn c231_l249_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c231_l249_action_invoke"); + let result = instance.call("add", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 250 +fn c232_l250_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c232_l250_action_invoke"); + let result = instance.call("add", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 251 +fn c233_l251_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c233_l251_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c233_l251_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 252 +fn c234_l252_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c234_l252_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c234_l252_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 253 +fn c235_l253_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c235_l253_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c235_l253_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 254 +fn c236_l254_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c236_l254_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c236_l254_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 255 +fn c237_l255_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c237_l255_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c237_l255_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 256 +fn c238_l256_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c238_l256_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c238_l256_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 257 +fn c239_l257_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c239_l257_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c239_l257_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 258 +fn c240_l258_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c240_l258_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c240_l258_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 259 +fn c241_l259_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c241_l259_action_invoke"); + let result = instance.call("add", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 260 +fn c242_l260_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c242_l260_action_invoke"); + let result = instance.call("add", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 261 +fn c243_l261_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c243_l261_action_invoke"); + let result = instance.call("add", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 262 +fn c244_l262_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c244_l262_action_invoke"); + let result = instance.call("add", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 263 +fn c245_l263_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c245_l263_action_invoke"); + let result = instance.call("add", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 264 +fn c246_l264_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c246_l264_action_invoke"); + let result = instance.call("add", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 265 +fn c247_l265_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c247_l265_action_invoke"); + let result = instance.call("add", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 266 +fn c248_l266_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c248_l266_action_invoke"); + let result = instance.call("add", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 267 +fn c249_l267_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c249_l267_action_invoke"); + let result = instance.call("add", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 268 +fn c250_l268_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c250_l268_action_invoke"); + let result = instance.call("add", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 269 +fn c251_l269_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c251_l269_action_invoke"); + let result = instance.call("add", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 270 +fn c252_l270_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c252_l270_action_invoke"); + let result = instance.call("add", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 271 +fn c253_l271_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c253_l271_action_invoke"); + let result = instance.call("add", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 272 +fn c254_l272_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c254_l272_action_invoke"); + let result = instance.call("add", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 273 +fn c255_l273_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c255_l273_action_invoke"); + let result = instance.call("add", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 274 +fn c256_l274_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c256_l274_action_invoke"); + let result = instance.call("add", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 275 +fn c257_l275_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c257_l275_action_invoke"); + let result = instance.call("add", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 276 +fn c258_l276_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c258_l276_action_invoke"); + let result = instance.call("add", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 277 +fn c259_l277_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c259_l277_action_invoke"); + let result = instance.call("add", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 278 +fn c260_l278_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c260_l278_action_invoke"); + let result = instance.call("add", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 279 +fn c261_l279_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c261_l279_action_invoke"); + let result = instance.call("add", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 280 +fn c262_l280_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c262_l280_action_invoke"); + let result = instance.call("add", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 281 +fn c263_l281_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c263_l281_action_invoke"); + let result = instance.call("add", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 282 +fn c264_l282_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c264_l282_action_invoke"); + let result = instance.call("add", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 283 +fn c265_l283_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c265_l283_action_invoke"); + let result = instance.call("add", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 284 +fn c266_l284_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c266_l284_action_invoke"); + let result = instance.call("add", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 285 +fn c267_l285_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c267_l285_action_invoke"); + let result = instance.call("add", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 286 +fn c268_l286_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c268_l286_action_invoke"); + let result = instance.call("add", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 287 +fn c269_l287_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c269_l287_action_invoke"); + let result = instance.call("add", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 288 +fn c270_l288_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c270_l288_action_invoke"); + let result = instance.call("add", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 289 +fn c271_l289_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c271_l289_action_invoke"); + let result = instance.call("add", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 290 +fn c272_l290_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c272_l290_action_invoke"); + let result = instance.call("add", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 291 +fn c273_l291_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c273_l291_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c273_l291_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 292 +fn c274_l292_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c274_l292_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c274_l292_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 293 +fn c275_l293_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c275_l293_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c275_l293_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 294 +fn c276_l294_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c276_l294_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c276_l294_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 295 +fn c277_l295_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c277_l295_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c277_l295_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 296 +fn c278_l296_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c278_l296_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c278_l296_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 297 +fn c279_l297_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c279_l297_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c279_l297_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 298 +fn c280_l298_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c280_l298_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c280_l298_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 299 +fn c281_l299_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c281_l299_action_invoke"); + let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 300 +fn c282_l300_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c282_l300_action_invoke"); + let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 301 +fn c283_l301_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c283_l301_action_invoke"); + let result = instance.call("add", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 302 +fn c284_l302_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c284_l302_action_invoke"); + let result = instance.call("add", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 303 +fn c285_l303_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c285_l303_action_invoke"); + let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 304 +fn c286_l304_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c286_l304_action_invoke"); + let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 305 +fn c287_l305_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c287_l305_action_invoke"); + let result = instance.call("add", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 306 +fn c288_l306_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c288_l306_action_invoke"); + let result = instance.call("add", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 307 +fn c289_l307_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c289_l307_action_invoke"); + let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 308 +fn c290_l308_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c290_l308_action_invoke"); + let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 309 +fn c291_l309_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c291_l309_action_invoke"); + let result = instance.call("add", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 310 +fn c292_l310_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c292_l310_action_invoke"); + let result = instance.call("add", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 311 +fn c293_l311_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c293_l311_action_invoke"); + let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 312 +fn c294_l312_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c294_l312_action_invoke"); + let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 313 +fn c295_l313_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c295_l313_action_invoke"); + let result = instance.call("add", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 314 +fn c296_l314_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c296_l314_action_invoke"); + let result = instance.call("add", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 315 +fn c297_l315_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c297_l315_action_invoke"); + let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 316 +fn c298_l316_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c298_l316_action_invoke"); + let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 317 +fn c299_l317_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c299_l317_action_invoke"); + let result = instance.call("add", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 318 +fn c300_l318_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c300_l318_action_invoke"); + let result = instance.call("add", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 319 +fn c301_l319_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c301_l319_action_invoke"); + let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 320 +fn c302_l320_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c302_l320_action_invoke"); + let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 321 +fn c303_l321_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c303_l321_action_invoke"); + let result = instance.call("add", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 322 +fn c304_l322_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c304_l322_action_invoke"); + let result = instance.call("add", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 323 +fn c305_l323_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c305_l323_action_invoke"); + let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 324 +fn c306_l324_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c306_l324_action_invoke"); + let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 325 +fn c307_l325_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c307_l325_action_invoke"); + let result = instance.call("add", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 326 +fn c308_l326_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c308_l326_action_invoke"); + let result = instance.call("add", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 327 +fn c309_l327_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c309_l327_action_invoke"); + let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 328 +fn c310_l328_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c310_l328_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::INFINITY.to_bits())]).unwrap().expect("Missing result in c310_l328_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 329 +fn c311_l329_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c311_l329_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c311_l329_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 330 +fn c312_l330_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c312_l330_action_invoke"); + let result = instance.call("add", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 331 +fn c313_l331_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c313_l331_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c313_l331_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 332 +fn c314_l332_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c314_l332_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c314_l332_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 333 +fn c315_l333_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c315_l333_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c315_l333_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 334 +fn c316_l334_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c316_l334_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c316_l334_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 335 +fn c317_l335_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c317_l335_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c317_l335_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 336 +fn c318_l336_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c318_l336_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c318_l336_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 337 +fn c319_l337_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c319_l337_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c319_l337_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 338 +fn c320_l338_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c320_l338_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c320_l338_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 339 +fn c321_l339_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c321_l339_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.0f64).to_bits())]).unwrap().expect("Missing result in c321_l339_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 340 +fn c322_l340_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c322_l340_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.0f64).to_bits())]).unwrap().expect("Missing result in c322_l340_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 341 +fn c323_l341_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c323_l341_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.0f64).to_bits())]).unwrap().expect("Missing result in c323_l341_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 342 +fn c324_l342_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c324_l342_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.0f64).to_bits())]).unwrap().expect("Missing result in c324_l342_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 343 +fn c325_l343_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c325_l343_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.0f64).to_bits())]).unwrap().expect("Missing result in c325_l343_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 344 +fn c326_l344_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c326_l344_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.0f64).to_bits())]).unwrap().expect("Missing result in c326_l344_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 345 +fn c327_l345_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c327_l345_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.0f64).to_bits())]).unwrap().expect("Missing result in c327_l345_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 346 +fn c328_l346_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c328_l346_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.0f64).to_bits())]).unwrap().expect("Missing result in c328_l346_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 347 +fn c329_l347_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c329_l347_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c329_l347_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 348 +fn c330_l348_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c330_l348_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c330_l348_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 349 +fn c331_l349_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c331_l349_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c331_l349_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 350 +fn c332_l350_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c332_l350_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c332_l350_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 351 +fn c333_l351_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c333_l351_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c333_l351_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 352 +fn c334_l352_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c334_l352_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c334_l352_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 353 +fn c335_l353_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c335_l353_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c335_l353_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 354 +fn c336_l354_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c336_l354_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c336_l354_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 355 +fn c337_l355_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c337_l355_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c337_l355_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 356 +fn c338_l356_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c338_l356_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c338_l356_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 357 +fn c339_l357_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c339_l357_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c339_l357_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 358 +fn c340_l358_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c340_l358_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c340_l358_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 359 +fn c341_l359_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c341_l359_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c341_l359_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 360 +fn c342_l360_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c342_l360_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c342_l360_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 361 +fn c343_l361_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c343_l361_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c343_l361_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 362 +fn c344_l362_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c344_l362_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c344_l362_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 363 +fn c345_l363_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c345_l363_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.5f64).to_bits())]).unwrap().expect("Missing result in c345_l363_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 364 +fn c346_l364_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c346_l364_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.5f64).to_bits())]).unwrap().expect("Missing result in c346_l364_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 365 +fn c347_l365_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c347_l365_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.5f64).to_bits())]).unwrap().expect("Missing result in c347_l365_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 366 +fn c348_l366_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c348_l366_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.5f64).to_bits())]).unwrap().expect("Missing result in c348_l366_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 367 +fn c349_l367_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c349_l367_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.5f64).to_bits())]).unwrap().expect("Missing result in c349_l367_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 368 +fn c350_l368_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c350_l368_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.5f64).to_bits())]).unwrap().expect("Missing result in c350_l368_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 369 +fn c351_l369_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c351_l369_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.5f64).to_bits())]).unwrap().expect("Missing result in c351_l369_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 370 +fn c352_l370_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c352_l370_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.5f64).to_bits())]).unwrap().expect("Missing result in c352_l370_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 371 +fn c353_l371_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c353_l371_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-1.0f64).to_bits())]).unwrap().expect("Missing result in c353_l371_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 372 +fn c354_l372_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c354_l372_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-1.0f64).to_bits())]).unwrap().expect("Missing result in c354_l372_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 373 +fn c355_l373_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c355_l373_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((1.0f64).to_bits())]).unwrap().expect("Missing result in c355_l373_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 374 +fn c356_l374_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c356_l374_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((1.0f64).to_bits())]).unwrap().expect("Missing result in c356_l374_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 375 +fn c357_l375_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c357_l375_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-1.0f64).to_bits())]).unwrap().expect("Missing result in c357_l375_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 376 +fn c358_l376_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c358_l376_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-1.0f64).to_bits())]).unwrap().expect("Missing result in c358_l376_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 377 +fn c359_l377_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c359_l377_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((1.0f64).to_bits())]).unwrap().expect("Missing result in c359_l377_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 378 +fn c360_l378_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c360_l378_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((1.0f64).to_bits())]).unwrap().expect("Missing result in c360_l378_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 379 +fn c361_l379_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c361_l379_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c361_l379_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 380 +fn c362_l380_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c362_l380_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c362_l380_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 381 +fn c363_l381_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c363_l381_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c363_l381_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 382 +fn c364_l382_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c364_l382_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c364_l382_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 383 +fn c365_l383_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c365_l383_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c365_l383_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 384 +fn c366_l384_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c366_l384_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c366_l384_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 385 +fn c367_l385_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c367_l385_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c367_l385_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 386 +fn c368_l386_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c368_l386_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c368_l386_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 387 +fn c369_l387_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c369_l387_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c369_l387_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 388 +fn c370_l388_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c370_l388_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c370_l388_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 389 +fn c371_l389_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c371_l389_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c371_l389_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 390 +fn c372_l390_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c372_l390_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c372_l390_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 391 +fn c373_l391_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c373_l391_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c373_l391_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 392 +fn c374_l392_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c374_l392_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c374_l392_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 393 +fn c375_l393_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c375_l393_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c375_l393_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 394 +fn c376_l394_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c376_l394_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c376_l394_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 395 +fn c377_l395_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c377_l395_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c377_l395_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 396 +fn c378_l396_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c378_l396_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c378_l396_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 397 +fn c379_l397_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c379_l397_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::INFINITY.to_bits())]).unwrap().expect("Missing result in c379_l397_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 398 +fn c380_l398_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c380_l398_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::INFINITY.to_bits())]).unwrap().expect("Missing result in c380_l398_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 399 +fn c381_l399_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c381_l399_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c381_l399_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 400 +fn c382_l400_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c382_l400_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c382_l400_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 401 +fn c383_l401_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c383_l401_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::INFINITY.to_bits())]).unwrap().expect("Missing result in c383_l401_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 402 +fn c384_l402_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c384_l402_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::INFINITY.to_bits())]).unwrap().expect("Missing result in c384_l402_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 403 +fn c385_l403_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c385_l403_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c385_l403_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 404 +fn c386_l404_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c386_l404_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c386_l404_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 405 +fn c387_l405_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c387_l405_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c387_l405_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 406 +fn c388_l406_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c388_l406_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c388_l406_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 407 +fn c389_l407_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c389_l407_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c389_l407_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 408 +fn c390_l408_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c390_l408_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c390_l408_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 409 +fn c391_l409_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c391_l409_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c391_l409_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 410 +fn c392_l410_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c392_l410_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c392_l410_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 411 +fn c393_l411_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c393_l411_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c393_l411_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 412 +fn c394_l412_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c394_l412_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c394_l412_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 413 +fn c395_l413_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c395_l413_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c395_l413_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 414 +fn c396_l414_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c396_l414_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c396_l414_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 415 +fn c397_l415_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c397_l415_assert_return_canonical_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c397_l415_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 416 +fn c398_l416_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c398_l416_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c398_l416_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 417 +fn c399_l417_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c399_l417_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c399_l417_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 418 +fn c400_l418_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c400_l418_assert_return_arithmetic_nan"); + let result = instance.call("add", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c400_l418_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 419 +fn c401_l419_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c401_l419_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 420 +fn c402_l420_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c402_l420_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 421 +fn c403_l421_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c403_l421_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 422 +fn c404_l422_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c404_l422_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 423 +fn c405_l423_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c405_l423_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 424 +fn c406_l424_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c406_l424_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 425 +fn c407_l425_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c407_l425_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 426 +fn c408_l426_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c408_l426_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 427 +fn c409_l427_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c409_l427_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 428 +fn c410_l428_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c410_l428_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 429 +fn c411_l429_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c411_l429_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 430 +fn c412_l430_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c412_l430_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 431 +fn c413_l431_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c413_l431_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 432 +fn c414_l432_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c414_l432_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 433 +fn c415_l433_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c415_l433_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 434 +fn c416_l434_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c416_l434_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 435 +fn c417_l435_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c417_l435_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 436 +fn c418_l436_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c418_l436_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 437 +fn c419_l437_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c419_l437_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 438 +fn c420_l438_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c420_l438_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 439 +fn c421_l439_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c421_l439_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 440 +fn c422_l440_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c422_l440_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 441 +fn c423_l441_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c423_l441_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 442 +fn c424_l442_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c424_l442_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 443 +fn c425_l443_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c425_l443_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 444 +fn c426_l444_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c426_l444_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 445 +fn c427_l445_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c427_l445_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 446 +fn c428_l446_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c428_l446_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 447 +fn c429_l447_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c429_l447_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 448 +fn c430_l448_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c430_l448_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 449 +fn c431_l449_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c431_l449_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 450 +fn c432_l450_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c432_l450_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 451 +fn c433_l451_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c433_l451_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c433_l451_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 452 +fn c434_l452_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c434_l452_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c434_l452_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 453 +fn c435_l453_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c435_l453_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c435_l453_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 454 +fn c436_l454_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c436_l454_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c436_l454_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 455 +fn c437_l455_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c437_l455_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c437_l455_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 456 +fn c438_l456_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c438_l456_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c438_l456_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 457 +fn c439_l457_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c439_l457_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c439_l457_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 458 +fn c440_l458_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c440_l458_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c440_l458_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 459 +fn c441_l459_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c441_l459_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 460 +fn c442_l460_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c442_l460_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 461 +fn c443_l461_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c443_l461_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 462 +fn c444_l462_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c444_l462_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 463 +fn c445_l463_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c445_l463_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 464 +fn c446_l464_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c446_l464_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001f64).to_bits())))); + result.map(|_| ()) +} + +// Line 465 +fn c447_l465_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c447_l465_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001f64).to_bits())))); + result.map(|_| ()) +} + +// Line 466 +fn c448_l466_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c448_l466_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 467 +fn c449_l467_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c449_l467_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201f64).to_bits())))); + result.map(|_| ()) +} + +// Line 468 +fn c450_l468_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c450_l468_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507202f64).to_bits())))); + result.map(|_| ()) +} + +// Line 469 +fn c451_l469_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c451_l469_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507202f64).to_bits())))); + result.map(|_| ()) +} + +// Line 470 +fn c452_l470_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c452_l470_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201f64).to_bits())))); + result.map(|_| ()) +} + +// Line 471 +fn c453_l471_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c453_l471_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 472 +fn c454_l472_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c454_l472_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 473 +fn c455_l473_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c455_l473_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 474 +fn c456_l474_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c456_l474_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 475 +fn c457_l475_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c457_l475_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 476 +fn c458_l476_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c458_l476_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 477 +fn c459_l477_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c459_l477_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 478 +fn c460_l478_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c460_l478_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 479 +fn c461_l479_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c461_l479_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 480 +fn c462_l480_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c462_l480_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 481 +fn c463_l481_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c463_l481_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 482 +fn c464_l482_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c464_l482_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 483 +fn c465_l483_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c465_l483_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 484 +fn c466_l484_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c466_l484_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 485 +fn c467_l485_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c467_l485_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 486 +fn c468_l486_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c468_l486_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 487 +fn c469_l487_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c469_l487_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 488 +fn c470_l488_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c470_l488_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 489 +fn c471_l489_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c471_l489_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 490 +fn c472_l490_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c472_l490_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 491 +fn c473_l491_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c473_l491_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c473_l491_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 492 +fn c474_l492_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c474_l492_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c474_l492_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 493 +fn c475_l493_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c475_l493_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c475_l493_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 494 +fn c476_l494_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c476_l494_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c476_l494_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 495 +fn c477_l495_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c477_l495_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c477_l495_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 496 +fn c478_l496_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c478_l496_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c478_l496_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 497 +fn c479_l497_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c479_l497_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c479_l497_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 498 +fn c480_l498_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c480_l498_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c480_l498_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 499 +fn c481_l499_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c481_l499_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 500 +fn c482_l500_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c482_l500_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 501 +fn c483_l501_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c483_l501_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 502 +fn c484_l502_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c484_l502_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 503 +fn c485_l503_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c485_l503_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201f64).to_bits())))); + result.map(|_| ()) +} + +// Line 504 +fn c486_l504_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c486_l504_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507202f64).to_bits())))); + result.map(|_| ()) +} + +// Line 505 +fn c487_l505_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c487_l505_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507202f64).to_bits())))); + result.map(|_| ()) +} + +// Line 506 +fn c488_l506_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c488_l506_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201f64).to_bits())))); + result.map(|_| ()) +} + +// Line 507 +fn c489_l507_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c489_l507_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 508 +fn c490_l508_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c490_l508_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004450147717014403f64).to_bits())))); + result.map(|_| ()) +} + +// Line 509 +fn c491_l509_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c491_l509_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004450147717014403f64).to_bits())))); + result.map(|_| ()) +} + +// Line 510 +fn c492_l510_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c492_l510_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 511 +fn c493_l511_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c493_l511_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 512 +fn c494_l512_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c494_l512_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 513 +fn c495_l513_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c495_l513_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 514 +fn c496_l514_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c496_l514_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 515 +fn c497_l515_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c497_l515_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 516 +fn c498_l516_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c498_l516_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 517 +fn c499_l517_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c499_l517_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 518 +fn c500_l518_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c500_l518_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 519 +fn c501_l519_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c501_l519_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 520 +fn c502_l520_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c502_l520_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 521 +fn c503_l521_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c503_l521_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 522 +fn c504_l522_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c504_l522_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 523 +fn c505_l523_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c505_l523_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 524 +fn c506_l524_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c506_l524_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 525 +fn c507_l525_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c507_l525_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 526 +fn c508_l526_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c508_l526_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 527 +fn c509_l527_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c509_l527_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 528 +fn c510_l528_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c510_l528_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 529 +fn c511_l529_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c511_l529_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 530 +fn c512_l530_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c512_l530_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 531 +fn c513_l531_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c513_l531_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c513_l531_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 532 +fn c514_l532_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c514_l532_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c514_l532_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 533 +fn c515_l533_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c515_l533_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c515_l533_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 534 +fn c516_l534_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c516_l534_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c516_l534_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 535 +fn c517_l535_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c517_l535_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c517_l535_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 536 +fn c518_l536_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c518_l536_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c518_l536_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 537 +fn c519_l537_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c519_l537_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c519_l537_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 538 +fn c520_l538_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c520_l538_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c520_l538_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 539 +fn c521_l539_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c521_l539_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 540 +fn c522_l540_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c522_l540_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 541 +fn c523_l541_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c523_l541_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 542 +fn c524_l542_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c524_l542_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.5f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 543 +fn c525_l543_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c525_l543_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 544 +fn c526_l544_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c526_l544_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 545 +fn c527_l545_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c527_l545_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 546 +fn c528_l546_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c528_l546_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 547 +fn c529_l547_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c529_l547_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 548 +fn c530_l548_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c530_l548_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 549 +fn c531_l549_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c531_l549_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 550 +fn c532_l550_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c532_l550_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 551 +fn c533_l551_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c533_l551_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 552 +fn c534_l552_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c534_l552_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 553 +fn c535_l553_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c535_l553_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 554 +fn c536_l554_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c536_l554_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.5f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 555 +fn c537_l555_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c537_l555_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.5f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 556 +fn c538_l556_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c538_l556_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.5f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 557 +fn c539_l557_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c539_l557_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.5f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 558 +fn c540_l558_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c540_l558_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.5f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 559 +fn c541_l559_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c541_l559_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.5f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((5.783185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 560 +fn c542_l560_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c542_l560_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.5f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.783185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 561 +fn c543_l561_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c543_l561_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.5f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.783185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 562 +fn c544_l562_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c544_l562_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.5f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-5.783185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 563 +fn c545_l563_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c545_l563_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.5f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 564 +fn c546_l564_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c546_l564_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.5f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 565 +fn c547_l565_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c547_l565_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.5f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 566 +fn c548_l566_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c548_l566_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.5f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 567 +fn c549_l567_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c549_l567_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 568 +fn c550_l568_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c550_l568_action_invoke"); + let result = instance.call("sub", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 569 +fn c551_l569_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c551_l569_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 570 +fn c552_l570_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c552_l570_action_invoke"); + let result = instance.call("sub", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 571 +fn c553_l571_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c553_l571_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c553_l571_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 572 +fn c554_l572_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c554_l572_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c554_l572_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 573 +fn c555_l573_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c555_l573_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c555_l573_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 574 +fn c556_l574_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c556_l574_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c556_l574_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 575 +fn c557_l575_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c557_l575_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c557_l575_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 576 +fn c558_l576_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c558_l576_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c558_l576_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 577 +fn c559_l577_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c559_l577_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c559_l577_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 578 +fn c560_l578_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c560_l578_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c560_l578_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 579 +fn c561_l579_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c561_l579_action_invoke"); + let result = instance.call("sub", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 580 +fn c562_l580_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c562_l580_action_invoke"); + let result = instance.call("sub", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 581 +fn c563_l581_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c563_l581_action_invoke"); + let result = instance.call("sub", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 582 +fn c564_l582_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c564_l582_action_invoke"); + let result = instance.call("sub", &[Value::F64((1.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 583 +fn c565_l583_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c565_l583_action_invoke"); + let result = instance.call("sub", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 584 +fn c566_l584_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c566_l584_action_invoke"); + let result = instance.call("sub", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 585 +fn c567_l585_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c567_l585_action_invoke"); + let result = instance.call("sub", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 586 +fn c568_l586_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c568_l586_action_invoke"); + let result = instance.call("sub", &[Value::F64((1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 587 +fn c569_l587_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c569_l587_action_invoke"); + let result = instance.call("sub", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 588 +fn c570_l588_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c570_l588_action_invoke"); + let result = instance.call("sub", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 589 +fn c571_l589_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c571_l589_action_invoke"); + let result = instance.call("sub", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 590 +fn c572_l590_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c572_l590_action_invoke"); + let result = instance.call("sub", &[Value::F64((1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 591 +fn c573_l591_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c573_l591_action_invoke"); + let result = instance.call("sub", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 592 +fn c574_l592_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c574_l592_action_invoke"); + let result = instance.call("sub", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 593 +fn c575_l593_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c575_l593_action_invoke"); + let result = instance.call("sub", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 594 +fn c576_l594_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c576_l594_action_invoke"); + let result = instance.call("sub", &[Value::F64((1.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 595 +fn c577_l595_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c577_l595_action_invoke"); + let result = instance.call("sub", &[Value::F64((-1.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 596 +fn c578_l596_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c578_l596_action_invoke"); + let result = instance.call("sub", &[Value::F64((-1.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-2.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 597 +fn c579_l597_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c579_l597_action_invoke"); + let result = instance.call("sub", &[Value::F64((1.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((2.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 598 +fn c580_l598_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c580_l598_action_invoke"); + let result = instance.call("sub", &[Value::F64((1.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 599 +fn c581_l599_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c581_l599_action_invoke"); + let result = instance.call("sub", &[Value::F64((-1.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((5.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 600 +fn c582_l600_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c582_l600_action_invoke"); + let result = instance.call("sub", &[Value::F64((-1.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-7.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 601 +fn c583_l601_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c583_l601_action_invoke"); + let result = instance.call("sub", &[Value::F64((1.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((7.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 602 +fn c584_l602_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c584_l602_action_invoke"); + let result = instance.call("sub", &[Value::F64((1.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-5.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 603 +fn c585_l603_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c585_l603_action_invoke"); + let result = instance.call("sub", &[Value::F64((-1.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 604 +fn c586_l604_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c586_l604_action_invoke"); + let result = instance.call("sub", &[Value::F64((-1.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 605 +fn c587_l605_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c587_l605_action_invoke"); + let result = instance.call("sub", &[Value::F64((1.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 606 +fn c588_l606_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c588_l606_action_invoke"); + let result = instance.call("sub", &[Value::F64((1.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 607 +fn c589_l607_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c589_l607_action_invoke"); + let result = instance.call("sub", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 608 +fn c590_l608_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c590_l608_action_invoke"); + let result = instance.call("sub", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 609 +fn c591_l609_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c591_l609_action_invoke"); + let result = instance.call("sub", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 610 +fn c592_l610_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c592_l610_action_invoke"); + let result = instance.call("sub", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 611 +fn c593_l611_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c593_l611_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c593_l611_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 612 +fn c594_l612_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c594_l612_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c594_l612_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 613 +fn c595_l613_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c595_l613_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c595_l613_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 614 +fn c596_l614_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c596_l614_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c596_l614_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 615 +fn c597_l615_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c597_l615_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c597_l615_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 616 +fn c598_l616_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c598_l616_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c598_l616_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 617 +fn c599_l617_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c599_l617_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c599_l617_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 618 +fn c600_l618_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c600_l618_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c600_l618_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 619 +fn c601_l619_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c601_l619_action_invoke"); + let result = instance.call("sub", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 620 +fn c602_l620_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c602_l620_action_invoke"); + let result = instance.call("sub", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 621 +fn c603_l621_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c603_l621_action_invoke"); + let result = instance.call("sub", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 622 +fn c604_l622_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c604_l622_action_invoke"); + let result = instance.call("sub", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 623 +fn c605_l623_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c605_l623_action_invoke"); + let result = instance.call("sub", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 624 +fn c606_l624_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c606_l624_action_invoke"); + let result = instance.call("sub", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 625 +fn c607_l625_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c607_l625_action_invoke"); + let result = instance.call("sub", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 626 +fn c608_l626_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c608_l626_action_invoke"); + let result = instance.call("sub", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 627 +fn c609_l627_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c609_l627_action_invoke"); + let result = instance.call("sub", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 628 +fn c610_l628_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c610_l628_action_invoke"); + let result = instance.call("sub", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 629 +fn c611_l629_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c611_l629_action_invoke"); + let result = instance.call("sub", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 630 +fn c612_l630_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c612_l630_action_invoke"); + let result = instance.call("sub", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 631 +fn c613_l631_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c613_l631_action_invoke"); + let result = instance.call("sub", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-5.783185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 632 +fn c614_l632_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c614_l632_action_invoke"); + let result = instance.call("sub", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.783185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 633 +fn c615_l633_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c615_l633_action_invoke"); + let result = instance.call("sub", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.783185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 634 +fn c616_l634_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c616_l634_action_invoke"); + let result = instance.call("sub", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((5.783185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 635 +fn c617_l635_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c617_l635_action_invoke"); + let result = instance.call("sub", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-5.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 636 +fn c618_l636_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c618_l636_action_invoke"); + let result = instance.call("sub", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-7.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 637 +fn c619_l637_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c619_l637_action_invoke"); + let result = instance.call("sub", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((7.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 638 +fn c620_l638_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c620_l638_action_invoke"); + let result = instance.call("sub", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((5.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 639 +fn c621_l639_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c621_l639_action_invoke"); + let result = instance.call("sub", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 640 +fn c622_l640_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c622_l640_action_invoke"); + let result = instance.call("sub", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-12.566370614359172f64).to_bits())))); + result.map(|_| ()) +} + +// Line 641 +fn c623_l641_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c623_l641_action_invoke"); + let result = instance.call("sub", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((12.566370614359172f64).to_bits())))); + result.map(|_| ()) +} + +// Line 642 +fn c624_l642_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c624_l642_action_invoke"); + let result = instance.call("sub", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 643 +fn c625_l643_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c625_l643_action_invoke"); + let result = instance.call("sub", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 644 +fn c626_l644_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c626_l644_action_invoke"); + let result = instance.call("sub", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 645 +fn c627_l645_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c627_l645_action_invoke"); + let result = instance.call("sub", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 646 +fn c628_l646_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c628_l646_action_invoke"); + let result = instance.call("sub", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 647 +fn c629_l647_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c629_l647_action_invoke"); + let result = instance.call("sub", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 648 +fn c630_l648_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c630_l648_action_invoke"); + let result = instance.call("sub", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 649 +fn c631_l649_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c631_l649_action_invoke"); + let result = instance.call("sub", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 650 +fn c632_l650_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c632_l650_action_invoke"); + let result = instance.call("sub", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 651 +fn c633_l651_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c633_l651_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c633_l651_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 652 +fn c634_l652_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c634_l652_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c634_l652_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 653 +fn c635_l653_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c635_l653_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c635_l653_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 654 +fn c636_l654_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c636_l654_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c636_l654_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 655 +fn c637_l655_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c637_l655_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c637_l655_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 656 +fn c638_l656_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c638_l656_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c638_l656_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 657 +fn c639_l657_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c639_l657_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c639_l657_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 658 +fn c640_l658_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c640_l658_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c640_l658_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 659 +fn c641_l659_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c641_l659_action_invoke"); + let result = instance.call("sub", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 660 +fn c642_l660_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c642_l660_action_invoke"); + let result = instance.call("sub", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 661 +fn c643_l661_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c643_l661_action_invoke"); + let result = instance.call("sub", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 662 +fn c644_l662_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c644_l662_action_invoke"); + let result = instance.call("sub", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 663 +fn c645_l663_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c645_l663_action_invoke"); + let result = instance.call("sub", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 664 +fn c646_l664_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c646_l664_action_invoke"); + let result = instance.call("sub", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 665 +fn c647_l665_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c647_l665_action_invoke"); + let result = instance.call("sub", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 666 +fn c648_l666_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c648_l666_action_invoke"); + let result = instance.call("sub", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 667 +fn c649_l667_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c649_l667_action_invoke"); + let result = instance.call("sub", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 668 +fn c650_l668_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c650_l668_action_invoke"); + let result = instance.call("sub", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 669 +fn c651_l669_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c651_l669_action_invoke"); + let result = instance.call("sub", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 670 +fn c652_l670_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c652_l670_action_invoke"); + let result = instance.call("sub", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 671 +fn c653_l671_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c653_l671_action_invoke"); + let result = instance.call("sub", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 672 +fn c654_l672_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c654_l672_action_invoke"); + let result = instance.call("sub", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 673 +fn c655_l673_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c655_l673_action_invoke"); + let result = instance.call("sub", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 674 +fn c656_l674_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c656_l674_action_invoke"); + let result = instance.call("sub", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 675 +fn c657_l675_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c657_l675_action_invoke"); + let result = instance.call("sub", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 676 +fn c658_l676_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c658_l676_action_invoke"); + let result = instance.call("sub", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 677 +fn c659_l677_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c659_l677_action_invoke"); + let result = instance.call("sub", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 678 +fn c660_l678_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c660_l678_action_invoke"); + let result = instance.call("sub", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 679 +fn c661_l679_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c661_l679_action_invoke"); + let result = instance.call("sub", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 680 +fn c662_l680_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c662_l680_action_invoke"); + let result = instance.call("sub", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 681 +fn c663_l681_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c663_l681_action_invoke"); + let result = instance.call("sub", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 682 +fn c664_l682_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c664_l682_action_invoke"); + let result = instance.call("sub", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 683 +fn c665_l683_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c665_l683_action_invoke"); + let result = instance.call("sub", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 684 +fn c666_l684_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c666_l684_action_invoke"); + let result = instance.call("sub", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 685 +fn c667_l685_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c667_l685_action_invoke"); + let result = instance.call("sub", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 686 +fn c668_l686_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c668_l686_action_invoke"); + let result = instance.call("sub", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 687 +fn c669_l687_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c669_l687_action_invoke"); + let result = instance.call("sub", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 688 +fn c670_l688_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c670_l688_action_invoke"); + let result = instance.call("sub", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 689 +fn c671_l689_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c671_l689_action_invoke"); + let result = instance.call("sub", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 690 +fn c672_l690_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c672_l690_action_invoke"); + let result = instance.call("sub", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 691 +fn c673_l691_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c673_l691_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c673_l691_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 692 +fn c674_l692_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c674_l692_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c674_l692_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 693 +fn c675_l693_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c675_l693_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c675_l693_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 694 +fn c676_l694_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c676_l694_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c676_l694_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 695 +fn c677_l695_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c677_l695_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c677_l695_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 696 +fn c678_l696_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c678_l696_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c678_l696_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 697 +fn c679_l697_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c679_l697_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c679_l697_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 698 +fn c680_l698_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c680_l698_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c680_l698_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 699 +fn c681_l699_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c681_l699_action_invoke"); + let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 700 +fn c682_l700_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c682_l700_action_invoke"); + let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 701 +fn c683_l701_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c683_l701_action_invoke"); + let result = instance.call("sub", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 702 +fn c684_l702_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c684_l702_action_invoke"); + let result = instance.call("sub", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 703 +fn c685_l703_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c685_l703_action_invoke"); + let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 704 +fn c686_l704_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c686_l704_action_invoke"); + let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 705 +fn c687_l705_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c687_l705_action_invoke"); + let result = instance.call("sub", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 706 +fn c688_l706_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c688_l706_action_invoke"); + let result = instance.call("sub", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 707 +fn c689_l707_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c689_l707_action_invoke"); + let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 708 +fn c690_l708_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c690_l708_action_invoke"); + let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 709 +fn c691_l709_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c691_l709_action_invoke"); + let result = instance.call("sub", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 710 +fn c692_l710_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c692_l710_action_invoke"); + let result = instance.call("sub", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 711 +fn c693_l711_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c693_l711_action_invoke"); + let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 712 +fn c694_l712_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c694_l712_action_invoke"); + let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 713 +fn c695_l713_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c695_l713_action_invoke"); + let result = instance.call("sub", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 714 +fn c696_l714_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c696_l714_action_invoke"); + let result = instance.call("sub", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 715 +fn c697_l715_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c697_l715_action_invoke"); + let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 716 +fn c698_l716_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c698_l716_action_invoke"); + let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 717 +fn c699_l717_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c699_l717_action_invoke"); + let result = instance.call("sub", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 718 +fn c700_l718_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c700_l718_action_invoke"); + let result = instance.call("sub", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 719 +fn c701_l719_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c701_l719_action_invoke"); + let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 720 +fn c702_l720_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c702_l720_action_invoke"); + let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 721 +fn c703_l721_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c703_l721_action_invoke"); + let result = instance.call("sub", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 722 +fn c704_l722_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c704_l722_action_invoke"); + let result = instance.call("sub", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 723 +fn c705_l723_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c705_l723_action_invoke"); + let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 724 +fn c706_l724_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c706_l724_action_invoke"); + let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 725 +fn c707_l725_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c707_l725_action_invoke"); + let result = instance.call("sub", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 726 +fn c708_l726_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c708_l726_action_invoke"); + let result = instance.call("sub", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 727 +fn c709_l727_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c709_l727_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c709_l727_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 728 +fn c710_l728_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c710_l728_action_invoke"); + let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 729 +fn c711_l729_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c711_l729_action_invoke"); + let result = instance.call("sub", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 730 +fn c712_l730_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c712_l730_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::INFINITY.to_bits())]).unwrap().expect("Missing result in c712_l730_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 731 +fn c713_l731_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c713_l731_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c713_l731_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 732 +fn c714_l732_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c714_l732_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c714_l732_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 733 +fn c715_l733_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c715_l733_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c715_l733_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 734 +fn c716_l734_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c716_l734_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c716_l734_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 735 +fn c717_l735_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c717_l735_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c717_l735_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 736 +fn c718_l736_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c718_l736_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c718_l736_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 737 +fn c719_l737_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c719_l737_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c719_l737_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 738 +fn c720_l738_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c720_l738_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c720_l738_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 739 +fn c721_l739_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c721_l739_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.0f64).to_bits())]).unwrap().expect("Missing result in c721_l739_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 740 +fn c722_l740_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c722_l740_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.0f64).to_bits())]).unwrap().expect("Missing result in c722_l740_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 741 +fn c723_l741_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c723_l741_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.0f64).to_bits())]).unwrap().expect("Missing result in c723_l741_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 742 +fn c724_l742_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c724_l742_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.0f64).to_bits())]).unwrap().expect("Missing result in c724_l742_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 743 +fn c725_l743_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c725_l743_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.0f64).to_bits())]).unwrap().expect("Missing result in c725_l743_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 744 +fn c726_l744_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c726_l744_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.0f64).to_bits())]).unwrap().expect("Missing result in c726_l744_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 745 +fn c727_l745_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c727_l745_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.0f64).to_bits())]).unwrap().expect("Missing result in c727_l745_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 746 +fn c728_l746_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c728_l746_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.0f64).to_bits())]).unwrap().expect("Missing result in c728_l746_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 747 +fn c729_l747_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c729_l747_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c729_l747_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 748 +fn c730_l748_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c730_l748_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c730_l748_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 749 +fn c731_l749_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c731_l749_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c731_l749_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 750 +fn c732_l750_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c732_l750_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c732_l750_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 751 +fn c733_l751_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c733_l751_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c733_l751_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 752 +fn c734_l752_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c734_l752_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c734_l752_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 753 +fn c735_l753_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c735_l753_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c735_l753_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 754 +fn c736_l754_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c736_l754_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c736_l754_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 755 +fn c737_l755_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c737_l755_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c737_l755_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 756 +fn c738_l756_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c738_l756_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c738_l756_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 757 +fn c739_l757_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c739_l757_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c739_l757_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 758 +fn c740_l758_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c740_l758_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c740_l758_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 759 +fn c741_l759_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c741_l759_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c741_l759_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 760 +fn c742_l760_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c742_l760_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c742_l760_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 761 +fn c743_l761_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c743_l761_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c743_l761_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 762 +fn c744_l762_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c744_l762_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c744_l762_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 763 +fn c745_l763_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c745_l763_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.5f64).to_bits())]).unwrap().expect("Missing result in c745_l763_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 764 +fn c746_l764_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c746_l764_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.5f64).to_bits())]).unwrap().expect("Missing result in c746_l764_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 765 +fn c747_l765_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c747_l765_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.5f64).to_bits())]).unwrap().expect("Missing result in c747_l765_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 766 +fn c748_l766_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c748_l766_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.5f64).to_bits())]).unwrap().expect("Missing result in c748_l766_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 767 +fn c749_l767_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c749_l767_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.5f64).to_bits())]).unwrap().expect("Missing result in c749_l767_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 768 +fn c750_l768_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c750_l768_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.5f64).to_bits())]).unwrap().expect("Missing result in c750_l768_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 769 +fn c751_l769_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c751_l769_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.5f64).to_bits())]).unwrap().expect("Missing result in c751_l769_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 770 +fn c752_l770_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c752_l770_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.5f64).to_bits())]).unwrap().expect("Missing result in c752_l770_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 771 +fn c753_l771_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c753_l771_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-1.0f64).to_bits())]).unwrap().expect("Missing result in c753_l771_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 772 +fn c754_l772_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c754_l772_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-1.0f64).to_bits())]).unwrap().expect("Missing result in c754_l772_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 773 +fn c755_l773_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c755_l773_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((1.0f64).to_bits())]).unwrap().expect("Missing result in c755_l773_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 774 +fn c756_l774_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c756_l774_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((1.0f64).to_bits())]).unwrap().expect("Missing result in c756_l774_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 775 +fn c757_l775_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c757_l775_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-1.0f64).to_bits())]).unwrap().expect("Missing result in c757_l775_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 776 +fn c758_l776_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c758_l776_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-1.0f64).to_bits())]).unwrap().expect("Missing result in c758_l776_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 777 +fn c759_l777_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c759_l777_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((1.0f64).to_bits())]).unwrap().expect("Missing result in c759_l777_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 778 +fn c760_l778_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c760_l778_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((1.0f64).to_bits())]).unwrap().expect("Missing result in c760_l778_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 779 +fn c761_l779_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c761_l779_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c761_l779_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 780 +fn c762_l780_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c762_l780_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c762_l780_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 781 +fn c763_l781_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c763_l781_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c763_l781_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 782 +fn c764_l782_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c764_l782_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c764_l782_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 783 +fn c765_l783_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c765_l783_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c765_l783_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 784 +fn c766_l784_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c766_l784_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c766_l784_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 785 +fn c767_l785_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c767_l785_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c767_l785_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 786 +fn c768_l786_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c768_l786_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c768_l786_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 787 +fn c769_l787_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c769_l787_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c769_l787_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 788 +fn c770_l788_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c770_l788_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c770_l788_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 789 +fn c771_l789_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c771_l789_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c771_l789_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 790 +fn c772_l790_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c772_l790_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c772_l790_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 791 +fn c773_l791_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c773_l791_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c773_l791_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 792 +fn c774_l792_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c774_l792_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c774_l792_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 793 +fn c775_l793_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c775_l793_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c775_l793_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 794 +fn c776_l794_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c776_l794_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c776_l794_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 795 +fn c777_l795_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c777_l795_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c777_l795_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 796 +fn c778_l796_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c778_l796_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c778_l796_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 797 +fn c779_l797_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c779_l797_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::INFINITY.to_bits())]).unwrap().expect("Missing result in c779_l797_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 798 +fn c780_l798_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c780_l798_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::INFINITY.to_bits())]).unwrap().expect("Missing result in c780_l798_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 799 +fn c781_l799_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c781_l799_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c781_l799_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 800 +fn c782_l800_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c782_l800_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c782_l800_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 801 +fn c783_l801_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c783_l801_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::INFINITY.to_bits())]).unwrap().expect("Missing result in c783_l801_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 802 +fn c784_l802_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c784_l802_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::INFINITY.to_bits())]).unwrap().expect("Missing result in c784_l802_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 803 +fn c785_l803_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c785_l803_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c785_l803_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 804 +fn c786_l804_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c786_l804_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c786_l804_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 805 +fn c787_l805_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c787_l805_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c787_l805_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 806 +fn c788_l806_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c788_l806_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c788_l806_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 807 +fn c789_l807_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c789_l807_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c789_l807_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 808 +fn c790_l808_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c790_l808_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c790_l808_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 809 +fn c791_l809_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c791_l809_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c791_l809_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 810 +fn c792_l810_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c792_l810_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c792_l810_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 811 +fn c793_l811_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c793_l811_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c793_l811_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 812 +fn c794_l812_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c794_l812_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c794_l812_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 813 +fn c795_l813_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c795_l813_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c795_l813_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 814 +fn c796_l814_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c796_l814_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c796_l814_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 815 +fn c797_l815_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c797_l815_assert_return_canonical_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c797_l815_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 816 +fn c798_l816_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c798_l816_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c798_l816_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 817 +fn c799_l817_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c799_l817_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c799_l817_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 818 +fn c800_l818_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c800_l818_assert_return_arithmetic_nan"); + let result = instance.call("sub", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c800_l818_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 819 +fn c801_l819_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c801_l819_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 820 +fn c802_l820_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c802_l820_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 821 +fn c803_l821_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c803_l821_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 822 +fn c804_l822_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c804_l822_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 823 +fn c805_l823_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c805_l823_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 824 +fn c806_l824_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c806_l824_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 825 +fn c807_l825_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c807_l825_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 826 +fn c808_l826_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c808_l826_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 827 +fn c809_l827_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c809_l827_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 828 +fn c810_l828_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c810_l828_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 829 +fn c811_l829_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c811_l829_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 830 +fn c812_l830_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c812_l830_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 831 +fn c813_l831_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c813_l831_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 832 +fn c814_l832_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c814_l832_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 833 +fn c815_l833_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c815_l833_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 834 +fn c816_l834_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c816_l834_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 835 +fn c817_l835_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c817_l835_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 836 +fn c818_l836_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c818_l836_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 837 +fn c819_l837_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c819_l837_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 838 +fn c820_l838_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c820_l838_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 839 +fn c821_l839_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c821_l839_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 840 +fn c822_l840_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c822_l840_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 841 +fn c823_l841_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c823_l841_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 842 +fn c824_l842_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c824_l842_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 843 +fn c825_l843_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c825_l843_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 844 +fn c826_l844_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c826_l844_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 845 +fn c827_l845_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c827_l845_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 846 +fn c828_l846_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c828_l846_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 847 +fn c829_l847_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c829_l847_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c829_l847_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 848 +fn c830_l848_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c830_l848_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]).unwrap().expect("Missing result in c830_l848_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 849 +fn c831_l849_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c831_l849_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c831_l849_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 850 +fn c832_l850_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c832_l850_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]).unwrap().expect("Missing result in c832_l850_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 851 +fn c833_l851_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c833_l851_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c833_l851_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 852 +fn c834_l852_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c834_l852_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c834_l852_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 853 +fn c835_l853_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c835_l853_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c835_l853_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 854 +fn c836_l854_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c836_l854_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c836_l854_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 855 +fn c837_l855_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c837_l855_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c837_l855_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 856 +fn c838_l856_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c838_l856_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c838_l856_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 857 +fn c839_l857_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c839_l857_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c839_l857_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 858 +fn c840_l858_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c840_l858_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c840_l858_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 859 +fn c841_l859_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c841_l859_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 860 +fn c842_l860_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c842_l860_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 861 +fn c843_l861_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c843_l861_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 862 +fn c844_l862_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c844_l862_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 863 +fn c845_l863_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c845_l863_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 864 +fn c846_l864_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c846_l864_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 865 +fn c847_l865_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c847_l865_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 866 +fn c848_l866_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c848_l866_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 867 +fn c849_l867_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c849_l867_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 868 +fn c850_l868_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c850_l868_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 869 +fn c851_l869_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c851_l869_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 870 +fn c852_l870_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c852_l870_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 871 +fn c853_l871_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c853_l871_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 872 +fn c854_l872_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c854_l872_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 873 +fn c855_l873_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c855_l873_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 874 +fn c856_l874_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c856_l874_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 875 +fn c857_l875_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c857_l875_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 876 +fn c858_l876_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c858_l876_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 877 +fn c859_l877_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c859_l877_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 878 +fn c860_l878_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c860_l878_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 879 +fn c861_l879_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c861_l879_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003f64).to_bits())))); + result.map(|_| ()) +} + +// Line 880 +fn c862_l880_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c862_l880_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003f64).to_bits())))); + result.map(|_| ()) +} + +// Line 881 +fn c863_l881_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c863_l881_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003f64).to_bits())))); + result.map(|_| ()) +} + +// Line 882 +fn c864_l882_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c864_l882_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003f64).to_bits())))); + result.map(|_| ()) +} + +// Line 883 +fn c865_l883_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c865_l883_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0000000000000008881784197001251f64).to_bits())))); + result.map(|_| ()) +} + +// Line 884 +fn c866_l884_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c866_l884_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000008881784197001251f64).to_bits())))); + result.map(|_| ()) +} + +// Line 885 +fn c867_l885_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c867_l885_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000008881784197001251f64).to_bits())))); + result.map(|_| ()) +} + +// Line 886 +fn c868_l886_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c868_l886_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0000000000000008881784197001251f64).to_bits())))); + result.map(|_| ()) +} + +// Line 887 +fn c869_l887_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c869_l887_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 888 +fn c870_l888_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c870_l888_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 889 +fn c871_l889_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c871_l889_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 890 +fn c872_l890_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c872_l890_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 891 +fn c873_l891_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c873_l891_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c873_l891_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 892 +fn c874_l892_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c874_l892_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c874_l892_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 893 +fn c875_l893_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c875_l893_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c875_l893_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 894 +fn c876_l894_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c876_l894_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c876_l894_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 895 +fn c877_l895_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c877_l895_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c877_l895_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 896 +fn c878_l896_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c878_l896_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c878_l896_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 897 +fn c879_l897_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c879_l897_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c879_l897_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 898 +fn c880_l898_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c880_l898_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c880_l898_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 899 +fn c881_l899_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c881_l899_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 900 +fn c882_l900_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c882_l900_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 901 +fn c883_l901_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c883_l901_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 902 +fn c884_l902_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c884_l902_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 903 +fn c885_l903_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c885_l903_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 904 +fn c886_l904_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c886_l904_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 905 +fn c887_l905_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c887_l905_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 906 +fn c888_l906_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c888_l906_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 907 +fn c889_l907_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c889_l907_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 908 +fn c890_l908_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c890_l908_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 909 +fn c891_l909_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c891_l909_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 910 +fn c892_l910_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c892_l910_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 911 +fn c893_l911_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c893_l911_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011125369292536007f64).to_bits())))); + result.map(|_| ()) +} + +// Line 912 +fn c894_l912_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c894_l912_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011125369292536007f64).to_bits())))); + result.map(|_| ()) +} + +// Line 913 +fn c895_l913_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c895_l913_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011125369292536007f64).to_bits())))); + result.map(|_| ()) +} + +// Line 914 +fn c896_l914_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c896_l914_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011125369292536007f64).to_bits())))); + result.map(|_| ()) +} + +// Line 915 +fn c897_l915_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c897_l915_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 916 +fn c898_l916_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c898_l916_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 917 +fn c899_l917_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c899_l917_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 918 +fn c900_l918_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c900_l918_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 919 +fn c901_l919_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c901_l919_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013980551375161837f64).to_bits())))); + result.map(|_| ()) +} + +// Line 920 +fn c902_l920_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c902_l920_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013980551375161837f64).to_bits())))); + result.map(|_| ()) +} + +// Line 921 +fn c903_l921_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c903_l921_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013980551375161837f64).to_bits())))); + result.map(|_| ()) +} + +// Line 922 +fn c904_l922_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c904_l922_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013980551375161837f64).to_bits())))); + result.map(|_| ()) +} + +// Line 923 +fn c905_l923_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c905_l923_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((3.9999999999999996f64).to_bits())))); + result.map(|_| ()) +} + +// Line 924 +fn c906_l924_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c906_l924_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-3.9999999999999996f64).to_bits())))); + result.map(|_| ()) +} + +// Line 925 +fn c907_l925_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c907_l925_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-3.9999999999999996f64).to_bits())))); + result.map(|_| ()) +} + +// Line 926 +fn c908_l926_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c908_l926_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((3.9999999999999996f64).to_bits())))); + result.map(|_| ()) +} + +// Line 927 +fn c909_l927_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c909_l927_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 928 +fn c910_l928_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c910_l928_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 929 +fn c911_l929_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c911_l929_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 930 +fn c912_l930_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c912_l930_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 931 +fn c913_l931_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c913_l931_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c913_l931_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 932 +fn c914_l932_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c914_l932_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c914_l932_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 933 +fn c915_l933_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c915_l933_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c915_l933_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 934 +fn c916_l934_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c916_l934_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c916_l934_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 935 +fn c917_l935_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c917_l935_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c917_l935_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 936 +fn c918_l936_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c918_l936_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c918_l936_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 937 +fn c919_l937_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c919_l937_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c919_l937_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 938 +fn c920_l938_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c920_l938_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c920_l938_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 939 +fn c921_l939_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c921_l939_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 940 +fn c922_l940_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c922_l940_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 941 +fn c923_l941_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c923_l941_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 942 +fn c924_l942_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c924_l942_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.5f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 943 +fn c925_l943_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c925_l943_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 944 +fn c926_l944_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c926_l944_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 945 +fn c927_l945_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c927_l945_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 946 +fn c928_l946_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c928_l946_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 947 +fn c929_l947_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c929_l947_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011125369292536007f64).to_bits())))); + result.map(|_| ()) +} + +// Line 948 +fn c930_l948_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c930_l948_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011125369292536007f64).to_bits())))); + result.map(|_| ()) +} + +// Line 949 +fn c931_l949_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c931_l949_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011125369292536007f64).to_bits())))); + result.map(|_| ()) +} + +// Line 950 +fn c932_l950_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c932_l950_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011125369292536007f64).to_bits())))); + result.map(|_| ()) +} + +// Line 951 +fn c933_l951_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c933_l951_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.25f64).to_bits())))); + result.map(|_| ()) +} + +// Line 952 +fn c934_l952_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c934_l952_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.25f64).to_bits())))); + result.map(|_| ()) +} + +// Line 953 +fn c935_l953_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c935_l953_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.25f64).to_bits())))); + result.map(|_| ()) +} + +// Line 954 +fn c936_l954_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c936_l954_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.5f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.25f64).to_bits())))); + result.map(|_| ()) +} + +// Line 955 +fn c937_l955_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c937_l955_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.5f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 956 +fn c938_l956_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c938_l956_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.5f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 957 +fn c939_l957_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c939_l957_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.5f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 958 +fn c940_l958_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c940_l958_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.5f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 959 +fn c941_l959_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c941_l959_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.5f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((3.141592653589793f64).to_bits())))); + result.map(|_| ()) +} + +// Line 960 +fn c942_l960_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c942_l960_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.5f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-3.141592653589793f64).to_bits())))); + result.map(|_| ()) +} + +// Line 961 +fn c943_l961_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c943_l961_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.5f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-3.141592653589793f64).to_bits())))); + result.map(|_| ()) +} + +// Line 962 +fn c944_l962_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c944_l962_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.5f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((3.141592653589793f64).to_bits())))); + result.map(|_| ()) +} + +// Line 963 +fn c945_l963_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c945_l963_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.5f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((89884656743115790000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 964 +fn c946_l964_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c946_l964_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.5f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-89884656743115790000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 965 +fn c947_l965_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c947_l965_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.5f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-89884656743115790000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 966 +fn c948_l966_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c948_l966_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.5f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((89884656743115790000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 967 +fn c949_l967_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c949_l967_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 968 +fn c950_l968_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c950_l968_action_invoke"); + let result = instance.call("mul", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 969 +fn c951_l969_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c951_l969_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 970 +fn c952_l970_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c952_l970_action_invoke"); + let result = instance.call("mul", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 971 +fn c953_l971_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c953_l971_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c953_l971_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 972 +fn c954_l972_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c954_l972_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c954_l972_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 973 +fn c955_l973_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c955_l973_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c955_l973_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 974 +fn c956_l974_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c956_l974_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c956_l974_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 975 +fn c957_l975_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c957_l975_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c957_l975_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 976 +fn c958_l976_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c958_l976_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c958_l976_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 977 +fn c959_l977_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c959_l977_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c959_l977_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 978 +fn c960_l978_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c960_l978_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c960_l978_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 979 +fn c961_l979_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c961_l979_action_invoke"); + let result = instance.call("mul", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 980 +fn c962_l980_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c962_l980_action_invoke"); + let result = instance.call("mul", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 981 +fn c963_l981_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c963_l981_action_invoke"); + let result = instance.call("mul", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 982 +fn c964_l982_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c964_l982_action_invoke"); + let result = instance.call("mul", &[Value::F64((1.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 983 +fn c965_l983_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c965_l983_action_invoke"); + let result = instance.call("mul", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 984 +fn c966_l984_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c966_l984_action_invoke"); + let result = instance.call("mul", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 985 +fn c967_l985_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c967_l985_action_invoke"); + let result = instance.call("mul", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 986 +fn c968_l986_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c968_l986_action_invoke"); + let result = instance.call("mul", &[Value::F64((1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 987 +fn c969_l987_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c969_l987_action_invoke"); + let result = instance.call("mul", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 988 +fn c970_l988_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c970_l988_action_invoke"); + let result = instance.call("mul", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 989 +fn c971_l989_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c971_l989_action_invoke"); + let result = instance.call("mul", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 990 +fn c972_l990_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c972_l990_action_invoke"); + let result = instance.call("mul", &[Value::F64((1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 991 +fn c973_l991_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c973_l991_action_invoke"); + let result = instance.call("mul", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 992 +fn c974_l992_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c974_l992_action_invoke"); + let result = instance.call("mul", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 993 +fn c975_l993_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c975_l993_action_invoke"); + let result = instance.call("mul", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 994 +fn c976_l994_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c976_l994_action_invoke"); + let result = instance.call("mul", &[Value::F64((1.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 995 +fn c977_l995_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c977_l995_action_invoke"); + let result = instance.call("mul", &[Value::F64((-1.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 996 +fn c978_l996_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c978_l996_action_invoke"); + let result = instance.call("mul", &[Value::F64((-1.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 997 +fn c979_l997_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c979_l997_action_invoke"); + let result = instance.call("mul", &[Value::F64((1.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 998 +fn c980_l998_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c980_l998_action_invoke"); + let result = instance.call("mul", &[Value::F64((1.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 999 +fn c981_l999_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c981_l999_action_invoke"); + let result = instance.call("mul", &[Value::F64((-1.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1000 +fn c982_l1000_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c982_l1000_action_invoke"); + let result = instance.call("mul", &[Value::F64((-1.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1001 +fn c983_l1001_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c983_l1001_action_invoke"); + let result = instance.call("mul", &[Value::F64((1.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1002 +fn c984_l1002_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c984_l1002_action_invoke"); + let result = instance.call("mul", &[Value::F64((1.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1003 +fn c985_l1003_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c985_l1003_action_invoke"); + let result = instance.call("mul", &[Value::F64((-1.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1004 +fn c986_l1004_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c986_l1004_action_invoke"); + let result = instance.call("mul", &[Value::F64((-1.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1005 +fn c987_l1005_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c987_l1005_action_invoke"); + let result = instance.call("mul", &[Value::F64((1.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1006 +fn c988_l1006_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c988_l1006_action_invoke"); + let result = instance.call("mul", &[Value::F64((1.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1007 +fn c989_l1007_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c989_l1007_action_invoke"); + let result = instance.call("mul", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1008 +fn c990_l1008_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c990_l1008_action_invoke"); + let result = instance.call("mul", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1009 +fn c991_l1009_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c991_l1009_action_invoke"); + let result = instance.call("mul", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1010 +fn c992_l1010_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c992_l1010_action_invoke"); + let result = instance.call("mul", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1011 +fn c993_l1011_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c993_l1011_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c993_l1011_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1012 +fn c994_l1012_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c994_l1012_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c994_l1012_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1013 +fn c995_l1013_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c995_l1013_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c995_l1013_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1014 +fn c996_l1014_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c996_l1014_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c996_l1014_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1015 +fn c997_l1015_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c997_l1015_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c997_l1015_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1016 +fn c998_l1016_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c998_l1016_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c998_l1016_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1017 +fn c999_l1017_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c999_l1017_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c999_l1017_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1018 +fn c1000_l1018_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1000_l1018_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1000_l1018_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1019 +fn c1001_l1019_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1001_l1019_action_invoke"); + let result = instance.call("mul", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1020 +fn c1002_l1020_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1002_l1020_action_invoke"); + let result = instance.call("mul", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1021 +fn c1003_l1021_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1003_l1021_action_invoke"); + let result = instance.call("mul", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1022 +fn c1004_l1022_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1004_l1022_action_invoke"); + let result = instance.call("mul", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1023 +fn c1005_l1023_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1005_l1023_action_invoke"); + let result = instance.call("mul", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1024 +fn c1006_l1024_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1006_l1024_action_invoke"); + let result = instance.call("mul", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1025 +fn c1007_l1025_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1007_l1025_action_invoke"); + let result = instance.call("mul", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1026 +fn c1008_l1026_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1008_l1026_action_invoke"); + let result = instance.call("mul", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1027 +fn c1009_l1027_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1009_l1027_action_invoke"); + let result = instance.call("mul", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013980551375161837f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1028 +fn c1010_l1028_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1010_l1028_action_invoke"); + let result = instance.call("mul", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013980551375161837f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1029 +fn c1011_l1029_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1011_l1029_action_invoke"); + let result = instance.call("mul", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013980551375161837f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1030 +fn c1012_l1030_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1012_l1030_action_invoke"); + let result = instance.call("mul", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013980551375161837f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1031 +fn c1013_l1031_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1013_l1031_action_invoke"); + let result = instance.call("mul", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((3.141592653589793f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1032 +fn c1014_l1032_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1014_l1032_action_invoke"); + let result = instance.call("mul", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-3.141592653589793f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1033 +fn c1015_l1033_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1015_l1033_action_invoke"); + let result = instance.call("mul", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-3.141592653589793f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1034 +fn c1016_l1034_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1016_l1034_action_invoke"); + let result = instance.call("mul", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((3.141592653589793f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1035 +fn c1017_l1035_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1017_l1035_action_invoke"); + let result = instance.call("mul", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1036 +fn c1018_l1036_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1018_l1036_action_invoke"); + let result = instance.call("mul", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1037 +fn c1019_l1037_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1019_l1037_action_invoke"); + let result = instance.call("mul", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1038 +fn c1020_l1038_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1020_l1038_action_invoke"); + let result = instance.call("mul", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1039 +fn c1021_l1039_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1021_l1039_action_invoke"); + let result = instance.call("mul", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((39.47841760435743f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1040 +fn c1022_l1040_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1022_l1040_action_invoke"); + let result = instance.call("mul", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-39.47841760435743f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1041 +fn c1023_l1041_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1023_l1041_action_invoke"); + let result = instance.call("mul", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-39.47841760435743f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1042 +fn c1024_l1042_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1024_l1042_action_invoke"); + let result = instance.call("mul", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((39.47841760435743f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1043 +fn c1025_l1043_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1025_l1043_action_invoke"); + let result = instance.call("mul", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1044 +fn c1026_l1044_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1026_l1044_action_invoke"); + let result = instance.call("mul", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1045 +fn c1027_l1045_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1027_l1045_action_invoke"); + let result = instance.call("mul", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1046 +fn c1028_l1046_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1028_l1046_action_invoke"); + let result = instance.call("mul", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1047 +fn c1029_l1047_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1029_l1047_action_invoke"); + let result = instance.call("mul", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1048 +fn c1030_l1048_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1030_l1048_action_invoke"); + let result = instance.call("mul", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1049 +fn c1031_l1049_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1031_l1049_action_invoke"); + let result = instance.call("mul", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1050 +fn c1032_l1050_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1032_l1050_action_invoke"); + let result = instance.call("mul", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1051 +fn c1033_l1051_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1033_l1051_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1033_l1051_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1052 +fn c1034_l1052_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1034_l1052_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1034_l1052_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1053 +fn c1035_l1053_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1035_l1053_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1035_l1053_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1054 +fn c1036_l1054_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1036_l1054_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1036_l1054_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1055 +fn c1037_l1055_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1037_l1055_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1037_l1055_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1056 +fn c1038_l1056_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1038_l1056_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1038_l1056_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1057 +fn c1039_l1057_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1039_l1057_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1039_l1057_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1058 +fn c1040_l1058_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1040_l1058_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1040_l1058_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1059 +fn c1041_l1059_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1041_l1059_action_invoke"); + let result = instance.call("mul", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1060 +fn c1042_l1060_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1042_l1060_action_invoke"); + let result = instance.call("mul", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1061 +fn c1043_l1061_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1043_l1061_action_invoke"); + let result = instance.call("mul", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1062 +fn c1044_l1062_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1044_l1062_action_invoke"); + let result = instance.call("mul", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1063 +fn c1045_l1063_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1045_l1063_action_invoke"); + let result = instance.call("mul", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0000000000000008881784197001251f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1064 +fn c1046_l1064_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1046_l1064_action_invoke"); + let result = instance.call("mul", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000008881784197001251f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1065 +fn c1047_l1065_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1047_l1065_action_invoke"); + let result = instance.call("mul", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000008881784197001251f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1066 +fn c1048_l1066_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1048_l1066_action_invoke"); + let result = instance.call("mul", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0000000000000008881784197001251f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1067 +fn c1049_l1067_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1049_l1067_action_invoke"); + let result = instance.call("mul", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((3.9999999999999996f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1068 +fn c1050_l1068_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1050_l1068_action_invoke"); + let result = instance.call("mul", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-3.9999999999999996f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1069 +fn c1051_l1069_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1051_l1069_action_invoke"); + let result = instance.call("mul", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-3.9999999999999996f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1070 +fn c1052_l1070_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1052_l1070_action_invoke"); + let result = instance.call("mul", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((3.9999999999999996f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1071 +fn c1053_l1071_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1053_l1071_action_invoke"); + let result = instance.call("mul", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((89884656743115790000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1072 +fn c1054_l1072_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1054_l1072_action_invoke"); + let result = instance.call("mul", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-89884656743115790000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1073 +fn c1055_l1073_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1055_l1073_action_invoke"); + let result = instance.call("mul", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-89884656743115790000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1074 +fn c1056_l1074_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1056_l1074_action_invoke"); + let result = instance.call("mul", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((89884656743115790000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1075 +fn c1057_l1075_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1057_l1075_action_invoke"); + let result = instance.call("mul", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1076 +fn c1058_l1076_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1058_l1076_action_invoke"); + let result = instance.call("mul", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1077 +fn c1059_l1077_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1059_l1077_action_invoke"); + let result = instance.call("mul", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1078 +fn c1060_l1078_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1060_l1078_action_invoke"); + let result = instance.call("mul", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1079 +fn c1061_l1079_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1061_l1079_action_invoke"); + let result = instance.call("mul", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1080 +fn c1062_l1080_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1062_l1080_action_invoke"); + let result = instance.call("mul", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1081 +fn c1063_l1081_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1063_l1081_action_invoke"); + let result = instance.call("mul", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1082 +fn c1064_l1082_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1064_l1082_action_invoke"); + let result = instance.call("mul", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1083 +fn c1065_l1083_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1065_l1083_action_invoke"); + let result = instance.call("mul", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1084 +fn c1066_l1084_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1066_l1084_action_invoke"); + let result = instance.call("mul", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1085 +fn c1067_l1085_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1067_l1085_action_invoke"); + let result = instance.call("mul", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1086 +fn c1068_l1086_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1068_l1086_action_invoke"); + let result = instance.call("mul", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1087 +fn c1069_l1087_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1069_l1087_action_invoke"); + let result = instance.call("mul", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1088 +fn c1070_l1088_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1070_l1088_action_invoke"); + let result = instance.call("mul", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1089 +fn c1071_l1089_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1071_l1089_action_invoke"); + let result = instance.call("mul", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1090 +fn c1072_l1090_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1072_l1090_action_invoke"); + let result = instance.call("mul", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1091 +fn c1073_l1091_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1073_l1091_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1073_l1091_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1092 +fn c1074_l1092_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1074_l1092_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1074_l1092_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1093 +fn c1075_l1093_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1075_l1093_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1075_l1093_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1094 +fn c1076_l1094_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1076_l1094_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1076_l1094_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1095 +fn c1077_l1095_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1077_l1095_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1077_l1095_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1096 +fn c1078_l1096_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1078_l1096_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1078_l1096_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1097 +fn c1079_l1097_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1079_l1097_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1079_l1097_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1098 +fn c1080_l1098_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1080_l1098_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1080_l1098_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1099 +fn c1081_l1099_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1081_l1099_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.0f64).to_bits())]).unwrap().expect("Missing result in c1081_l1099_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1100 +fn c1082_l1100_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1082_l1100_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.0f64).to_bits())]).unwrap().expect("Missing result in c1082_l1100_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1101 +fn c1083_l1101_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1083_l1101_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.0f64).to_bits())]).unwrap().expect("Missing result in c1083_l1101_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1102 +fn c1084_l1102_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1084_l1102_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.0f64).to_bits())]).unwrap().expect("Missing result in c1084_l1102_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1103 +fn c1085_l1103_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1085_l1103_action_invoke"); + let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1104 +fn c1086_l1104_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1086_l1104_action_invoke"); + let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1105 +fn c1087_l1105_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1087_l1105_action_invoke"); + let result = instance.call("mul", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1106 +fn c1088_l1106_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1088_l1106_action_invoke"); + let result = instance.call("mul", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1107 +fn c1089_l1107_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1089_l1107_action_invoke"); + let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1108 +fn c1090_l1108_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1090_l1108_action_invoke"); + let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1109 +fn c1091_l1109_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1091_l1109_action_invoke"); + let result = instance.call("mul", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1110 +fn c1092_l1110_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1092_l1110_action_invoke"); + let result = instance.call("mul", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1111 +fn c1093_l1111_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1093_l1111_action_invoke"); + let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1112 +fn c1094_l1112_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1094_l1112_action_invoke"); + let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1113 +fn c1095_l1113_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1095_l1113_action_invoke"); + let result = instance.call("mul", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1114 +fn c1096_l1114_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1096_l1114_action_invoke"); + let result = instance.call("mul", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1115 +fn c1097_l1115_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1097_l1115_action_invoke"); + let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1116 +fn c1098_l1116_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1098_l1116_action_invoke"); + let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1117 +fn c1099_l1117_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1099_l1117_action_invoke"); + let result = instance.call("mul", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1118 +fn c1100_l1118_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1100_l1118_action_invoke"); + let result = instance.call("mul", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1119 +fn c1101_l1119_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1101_l1119_action_invoke"); + let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1120 +fn c1102_l1120_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1102_l1120_action_invoke"); + let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1121 +fn c1103_l1121_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1103_l1121_action_invoke"); + let result = instance.call("mul", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1122 +fn c1104_l1122_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1104_l1122_action_invoke"); + let result = instance.call("mul", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1123 +fn c1105_l1123_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1105_l1123_action_invoke"); + let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1124 +fn c1106_l1124_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1106_l1124_action_invoke"); + let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1125 +fn c1107_l1125_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1107_l1125_action_invoke"); + let result = instance.call("mul", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1126 +fn c1108_l1126_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1108_l1126_action_invoke"); + let result = instance.call("mul", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1127 +fn c1109_l1127_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1109_l1127_action_invoke"); + let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1128 +fn c1110_l1128_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1110_l1128_action_invoke"); + let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1129 +fn c1111_l1129_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1111_l1129_action_invoke"); + let result = instance.call("mul", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1130 +fn c1112_l1130_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1112_l1130_action_invoke"); + let result = instance.call("mul", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1131 +fn c1113_l1131_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1113_l1131_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1113_l1131_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1132 +fn c1114_l1132_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1114_l1132_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1114_l1132_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1133 +fn c1115_l1133_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1115_l1133_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1115_l1133_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1134 +fn c1116_l1134_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1116_l1134_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1116_l1134_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1135 +fn c1117_l1135_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1117_l1135_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1117_l1135_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1136 +fn c1118_l1136_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1118_l1136_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1118_l1136_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1137 +fn c1119_l1137_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1119_l1137_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1119_l1137_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1138 +fn c1120_l1138_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1120_l1138_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1120_l1138_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1139 +fn c1121_l1139_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1121_l1139_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.0f64).to_bits())]).unwrap().expect("Missing result in c1121_l1139_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1140 +fn c1122_l1140_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1122_l1140_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.0f64).to_bits())]).unwrap().expect("Missing result in c1122_l1140_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1141 +fn c1123_l1141_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1123_l1141_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.0f64).to_bits())]).unwrap().expect("Missing result in c1123_l1141_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1142 +fn c1124_l1142_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1124_l1142_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.0f64).to_bits())]).unwrap().expect("Missing result in c1124_l1142_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1143 +fn c1125_l1143_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1125_l1143_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.0f64).to_bits())]).unwrap().expect("Missing result in c1125_l1143_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1144 +fn c1126_l1144_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1126_l1144_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.0f64).to_bits())]).unwrap().expect("Missing result in c1126_l1144_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1145 +fn c1127_l1145_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1127_l1145_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.0f64).to_bits())]).unwrap().expect("Missing result in c1127_l1145_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1146 +fn c1128_l1146_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1128_l1146_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.0f64).to_bits())]).unwrap().expect("Missing result in c1128_l1146_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1147 +fn c1129_l1147_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1129_l1147_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c1129_l1147_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1148 +fn c1130_l1148_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1130_l1148_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c1130_l1148_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1149 +fn c1131_l1149_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1131_l1149_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c1131_l1149_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1150 +fn c1132_l1150_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1132_l1150_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c1132_l1150_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1151 +fn c1133_l1151_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1133_l1151_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c1133_l1151_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1152 +fn c1134_l1152_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1134_l1152_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c1134_l1152_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1153 +fn c1135_l1153_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1135_l1153_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c1135_l1153_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1154 +fn c1136_l1154_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1136_l1154_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c1136_l1154_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1155 +fn c1137_l1155_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1137_l1155_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c1137_l1155_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1156 +fn c1138_l1156_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1138_l1156_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c1138_l1156_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1157 +fn c1139_l1157_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1139_l1157_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c1139_l1157_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1158 +fn c1140_l1158_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1140_l1158_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c1140_l1158_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1159 +fn c1141_l1159_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1141_l1159_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c1141_l1159_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1160 +fn c1142_l1160_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1142_l1160_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c1142_l1160_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1161 +fn c1143_l1161_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1143_l1161_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c1143_l1161_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1162 +fn c1144_l1162_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1144_l1162_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c1144_l1162_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1163 +fn c1145_l1163_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1145_l1163_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.5f64).to_bits())]).unwrap().expect("Missing result in c1145_l1163_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1164 +fn c1146_l1164_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1146_l1164_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.5f64).to_bits())]).unwrap().expect("Missing result in c1146_l1164_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1165 +fn c1147_l1165_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1147_l1165_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.5f64).to_bits())]).unwrap().expect("Missing result in c1147_l1165_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1166 +fn c1148_l1166_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1148_l1166_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.5f64).to_bits())]).unwrap().expect("Missing result in c1148_l1166_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1167 +fn c1149_l1167_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1149_l1167_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.5f64).to_bits())]).unwrap().expect("Missing result in c1149_l1167_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1168 +fn c1150_l1168_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1150_l1168_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.5f64).to_bits())]).unwrap().expect("Missing result in c1150_l1168_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1169 +fn c1151_l1169_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1151_l1169_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.5f64).to_bits())]).unwrap().expect("Missing result in c1151_l1169_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1170 +fn c1152_l1170_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1152_l1170_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.5f64).to_bits())]).unwrap().expect("Missing result in c1152_l1170_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1171 +fn c1153_l1171_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1153_l1171_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-1.0f64).to_bits())]).unwrap().expect("Missing result in c1153_l1171_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1172 +fn c1154_l1172_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1154_l1172_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-1.0f64).to_bits())]).unwrap().expect("Missing result in c1154_l1172_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1173 +fn c1155_l1173_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1155_l1173_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((1.0f64).to_bits())]).unwrap().expect("Missing result in c1155_l1173_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1174 +fn c1156_l1174_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1156_l1174_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((1.0f64).to_bits())]).unwrap().expect("Missing result in c1156_l1174_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1175 +fn c1157_l1175_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1157_l1175_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-1.0f64).to_bits())]).unwrap().expect("Missing result in c1157_l1175_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1176 +fn c1158_l1176_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1158_l1176_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-1.0f64).to_bits())]).unwrap().expect("Missing result in c1158_l1176_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1177 +fn c1159_l1177_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1159_l1177_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((1.0f64).to_bits())]).unwrap().expect("Missing result in c1159_l1177_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1178 +fn c1160_l1178_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1160_l1178_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((1.0f64).to_bits())]).unwrap().expect("Missing result in c1160_l1178_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1179 +fn c1161_l1179_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1161_l1179_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c1161_l1179_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1180 +fn c1162_l1180_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1162_l1180_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c1162_l1180_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1181 +fn c1163_l1181_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1163_l1181_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c1163_l1181_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1182 +fn c1164_l1182_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1164_l1182_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c1164_l1182_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1183 +fn c1165_l1183_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1165_l1183_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c1165_l1183_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1184 +fn c1166_l1184_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1166_l1184_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c1166_l1184_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1185 +fn c1167_l1185_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1167_l1185_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c1167_l1185_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1186 +fn c1168_l1186_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1168_l1186_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c1168_l1186_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1187 +fn c1169_l1187_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1169_l1187_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c1169_l1187_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1188 +fn c1170_l1188_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1170_l1188_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c1170_l1188_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1189 +fn c1171_l1189_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1171_l1189_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c1171_l1189_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1190 +fn c1172_l1190_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1172_l1190_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c1172_l1190_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1191 +fn c1173_l1191_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1173_l1191_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c1173_l1191_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1192 +fn c1174_l1192_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1174_l1192_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c1174_l1192_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1193 +fn c1175_l1193_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1175_l1193_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c1175_l1193_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1194 +fn c1176_l1194_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1176_l1194_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c1176_l1194_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1195 +fn c1177_l1195_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1177_l1195_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1177_l1195_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1196 +fn c1178_l1196_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1178_l1196_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1178_l1196_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1197 +fn c1179_l1197_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1179_l1197_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::INFINITY.to_bits())]).unwrap().expect("Missing result in c1179_l1197_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1198 +fn c1180_l1198_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1180_l1198_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::INFINITY.to_bits())]).unwrap().expect("Missing result in c1180_l1198_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1199 +fn c1181_l1199_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1181_l1199_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1181_l1199_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1200 +fn c1182_l1200_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1182_l1200_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1182_l1200_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1201 +fn c1183_l1201_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1183_l1201_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::INFINITY.to_bits())]).unwrap().expect("Missing result in c1183_l1201_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1202 +fn c1184_l1202_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1184_l1202_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::INFINITY.to_bits())]).unwrap().expect("Missing result in c1184_l1202_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1203 +fn c1185_l1203_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1185_l1203_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1185_l1203_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1204 +fn c1186_l1204_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1186_l1204_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1186_l1204_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1205 +fn c1187_l1205_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1187_l1205_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1187_l1205_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1206 +fn c1188_l1206_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1188_l1206_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1188_l1206_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1207 +fn c1189_l1207_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1189_l1207_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1189_l1207_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1208 +fn c1190_l1208_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1190_l1208_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1190_l1208_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1209 +fn c1191_l1209_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1191_l1209_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1191_l1209_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1210 +fn c1192_l1210_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1192_l1210_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1192_l1210_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1211 +fn c1193_l1211_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1193_l1211_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1193_l1211_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1212 +fn c1194_l1212_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1194_l1212_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1194_l1212_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1213 +fn c1195_l1213_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1195_l1213_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1195_l1213_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1214 +fn c1196_l1214_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1196_l1214_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1196_l1214_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1215 +fn c1197_l1215_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1197_l1215_assert_return_canonical_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1197_l1215_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1216 +fn c1198_l1216_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1198_l1216_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1198_l1216_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1217 +fn c1199_l1217_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1199_l1217_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1199_l1217_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1218 +fn c1200_l1218_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1200_l1218_assert_return_arithmetic_nan"); + let result = instance.call("mul", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1200_l1218_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1219 +fn c1201_l1219_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1201_l1219_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]).unwrap().expect("Missing result in c1201_l1219_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1220 +fn c1202_l1220_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1202_l1220_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]).unwrap().expect("Missing result in c1202_l1220_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1221 +fn c1203_l1221_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1203_l1221_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]).unwrap().expect("Missing result in c1203_l1221_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1222 +fn c1204_l1222_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1204_l1222_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64((0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]).unwrap().expect("Missing result in c1204_l1222_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1223 +fn c1205_l1223_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1205_l1223_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1224 +fn c1206_l1224_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1206_l1224_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1225 +fn c1207_l1225_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1207_l1225_action_invoke"); + let result = instance.call("div", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1226 +fn c1208_l1226_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1208_l1226_action_invoke"); + let result = instance.call("div", &[Value::F64((0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1227 +fn c1209_l1227_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1209_l1227_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1228 +fn c1210_l1228_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1210_l1228_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1229 +fn c1211_l1229_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1211_l1229_action_invoke"); + let result = instance.call("div", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1230 +fn c1212_l1230_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1212_l1230_action_invoke"); + let result = instance.call("div", &[Value::F64((0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1231 +fn c1213_l1231_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1213_l1231_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1232 +fn c1214_l1232_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1214_l1232_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1233 +fn c1215_l1233_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1215_l1233_action_invoke"); + let result = instance.call("div", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1234 +fn c1216_l1234_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1216_l1234_action_invoke"); + let result = instance.call("div", &[Value::F64((0.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1235 +fn c1217_l1235_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1217_l1235_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1236 +fn c1218_l1236_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1218_l1236_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1237 +fn c1219_l1237_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1219_l1237_action_invoke"); + let result = instance.call("div", &[Value::F64((0.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1238 +fn c1220_l1238_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1220_l1238_action_invoke"); + let result = instance.call("div", &[Value::F64((0.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1239 +fn c1221_l1239_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1221_l1239_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1240 +fn c1222_l1240_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1222_l1240_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1241 +fn c1223_l1241_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1223_l1241_action_invoke"); + let result = instance.call("div", &[Value::F64((0.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1242 +fn c1224_l1242_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1224_l1242_action_invoke"); + let result = instance.call("div", &[Value::F64((0.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1243 +fn c1225_l1243_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1225_l1243_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1244 +fn c1226_l1244_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1226_l1244_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1245 +fn c1227_l1245_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1227_l1245_action_invoke"); + let result = instance.call("div", &[Value::F64((0.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1246 +fn c1228_l1246_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1228_l1246_action_invoke"); + let result = instance.call("div", &[Value::F64((0.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1247 +fn c1229_l1247_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1229_l1247_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1248 +fn c1230_l1248_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1230_l1248_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1249 +fn c1231_l1249_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1231_l1249_action_invoke"); + let result = instance.call("div", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1250 +fn c1232_l1250_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1232_l1250_action_invoke"); + let result = instance.call("div", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1251 +fn c1233_l1251_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1233_l1251_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1233_l1251_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1252 +fn c1234_l1252_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1234_l1252_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1234_l1252_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1253 +fn c1235_l1253_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1235_l1253_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1235_l1253_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1254 +fn c1236_l1254_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1236_l1254_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1236_l1254_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1255 +fn c1237_l1255_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1237_l1255_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1237_l1255_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1256 +fn c1238_l1256_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1238_l1256_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1238_l1256_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1257 +fn c1239_l1257_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1239_l1257_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1239_l1257_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1258 +fn c1240_l1258_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1240_l1258_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1240_l1258_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1259 +fn c1241_l1259_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1241_l1259_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1260 +fn c1242_l1260_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1242_l1260_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1261 +fn c1243_l1261_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1243_l1261_action_invoke"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1262 +fn c1244_l1262_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1244_l1262_action_invoke"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1263 +fn c1245_l1263_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1245_l1263_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1264 +fn c1246_l1264_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1246_l1264_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1265 +fn c1247_l1265_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1247_l1265_action_invoke"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1266 +fn c1248_l1266_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1248_l1266_action_invoke"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1267 +fn c1249_l1267_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1249_l1267_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0000000000000002220446049250313f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1268 +fn c1250_l1268_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1250_l1268_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000002220446049250313f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1269 +fn c1251_l1269_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1251_l1269_action_invoke"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000002220446049250313f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1270 +fn c1252_l1270_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1252_l1270_action_invoke"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0000000000000002220446049250313f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1271 +fn c1253_l1271_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1253_l1271_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1272 +fn c1254_l1272_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1254_l1272_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1273 +fn c1255_l1273_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1255_l1273_action_invoke"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1274 +fn c1256_l1274_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1256_l1274_action_invoke"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1275 +fn c1257_l1275_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1257_l1275_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1276 +fn c1258_l1276_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1258_l1276_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1277 +fn c1259_l1277_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1259_l1277_action_invoke"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1278 +fn c1260_l1278_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1260_l1278_action_invoke"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1279 +fn c1261_l1279_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1261_l1279_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1280 +fn c1262_l1280_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1262_l1280_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1281 +fn c1263_l1281_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1263_l1281_action_invoke"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1282 +fn c1264_l1282_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1264_l1282_action_invoke"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1283 +fn c1265_l1283_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1265_l1283_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1284 +fn c1266_l1284_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1266_l1284_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1285 +fn c1267_l1285_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1267_l1285_action_invoke"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1286 +fn c1268_l1286_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1268_l1286_action_invoke"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1287 +fn c1269_l1287_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1269_l1287_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1288 +fn c1270_l1288_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1270_l1288_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1289 +fn c1271_l1289_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1271_l1289_action_invoke"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1290 +fn c1272_l1290_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1272_l1290_action_invoke"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1291 +fn c1273_l1291_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1273_l1291_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1273_l1291_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1292 +fn c1274_l1292_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1274_l1292_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1274_l1292_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1293 +fn c1275_l1293_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1275_l1293_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1275_l1293_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1294 +fn c1276_l1294_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1276_l1294_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1276_l1294_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1295 +fn c1277_l1295_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1277_l1295_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1277_l1295_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1296 +fn c1278_l1296_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1278_l1296_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1278_l1296_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1297 +fn c1279_l1297_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1279_l1297_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1279_l1297_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1298 +fn c1280_l1298_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1280_l1298_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1280_l1298_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1299 +fn c1281_l1299_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1281_l1299_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1300 +fn c1282_l1300_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1282_l1300_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1301 +fn c1283_l1301_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1283_l1301_action_invoke"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1302 +fn c1284_l1302_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1284_l1302_action_invoke"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1303 +fn c1285_l1303_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1285_l1303_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((4503599627370496.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1304 +fn c1286_l1304_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1286_l1304_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-4503599627370496.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1305 +fn c1287_l1305_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1287_l1305_action_invoke"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-4503599627370496.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1306 +fn c1288_l1306_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1288_l1306_action_invoke"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((4503599627370496.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1307 +fn c1289_l1307_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1289_l1307_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1308 +fn c1290_l1308_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1290_l1308_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1309 +fn c1291_l1309_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1291_l1309_action_invoke"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1310 +fn c1292_l1310_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1292_l1310_action_invoke"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1311 +fn c1293_l1311_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1293_l1311_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004450147717014403f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1312 +fn c1294_l1312_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1294_l1312_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004450147717014403f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1313 +fn c1295_l1313_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1295_l1313_action_invoke"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004450147717014403f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1314 +fn c1296_l1314_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1296_l1314_action_invoke"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004450147717014403f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1315 +fn c1297_l1315_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1297_l1315_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1316 +fn c1298_l1316_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1298_l1316_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1317 +fn c1299_l1317_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1299_l1317_action_invoke"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1318 +fn c1300_l1318_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1300_l1318_action_invoke"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1319 +fn c1301_l1319_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1301_l1319_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003541315033259774f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1320 +fn c1302_l1320_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1302_l1320_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003541315033259774f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1321 +fn c1303_l1321_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1303_l1321_action_invoke"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003541315033259774f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1322 +fn c1304_l1322_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1304_l1322_action_invoke"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003541315033259774f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1323 +fn c1305_l1323_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1305_l1323_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1324 +fn c1306_l1324_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1306_l1324_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1325 +fn c1307_l1325_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1307_l1325_action_invoke"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1326 +fn c1308_l1326_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1308_l1326_action_invoke"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1327 +fn c1309_l1327_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1309_l1327_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1328 +fn c1310_l1328_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1310_l1328_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1329 +fn c1311_l1329_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1311_l1329_action_invoke"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1330 +fn c1312_l1330_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1312_l1330_action_invoke"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1331 +fn c1313_l1331_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1313_l1331_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1313_l1331_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1332 +fn c1314_l1332_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1314_l1332_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1314_l1332_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1333 +fn c1315_l1333_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1315_l1333_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1315_l1333_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1334 +fn c1316_l1334_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1316_l1334_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1316_l1334_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1335 +fn c1317_l1335_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1317_l1335_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1317_l1335_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1336 +fn c1318_l1336_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1318_l1336_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1318_l1336_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1337 +fn c1319_l1337_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1319_l1337_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1319_l1337_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1338 +fn c1320_l1338_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1320_l1338_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1320_l1338_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1339 +fn c1321_l1339_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1321_l1339_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1340 +fn c1322_l1340_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1322_l1340_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1341 +fn c1323_l1341_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1323_l1341_action_invoke"); + let result = instance.call("div", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1342 +fn c1324_l1342_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1324_l1342_action_invoke"); + let result = instance.call("div", &[Value::F64((0.5f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1343 +fn c1325_l1343_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1325_l1343_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1344 +fn c1326_l1344_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1326_l1344_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1345 +fn c1327_l1345_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1327_l1345_action_invoke"); + let result = instance.call("div", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1346 +fn c1328_l1346_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1328_l1346_action_invoke"); + let result = instance.call("div", &[Value::F64((0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1347 +fn c1329_l1347_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1329_l1347_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((22471164185778950000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1348 +fn c1330_l1348_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1330_l1348_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-22471164185778950000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1349 +fn c1331_l1349_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1331_l1349_action_invoke"); + let result = instance.call("div", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-22471164185778950000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1350 +fn c1332_l1350_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1332_l1350_action_invoke"); + let result = instance.call("div", &[Value::F64((0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((22471164185778950000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1351 +fn c1333_l1351_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1333_l1351_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1352 +fn c1334_l1352_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1334_l1352_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1353 +fn c1335_l1353_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1335_l1353_action_invoke"); + let result = instance.call("div", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1354 +fn c1336_l1354_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1336_l1354_action_invoke"); + let result = instance.call("div", &[Value::F64((0.5f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1355 +fn c1337_l1355_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1337_l1355_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.5f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1356 +fn c1338_l1356_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1338_l1356_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.5f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1357 +fn c1339_l1357_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1339_l1357_action_invoke"); + let result = instance.call("div", &[Value::F64((0.5f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1358 +fn c1340_l1358_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1340_l1358_action_invoke"); + let result = instance.call("div", &[Value::F64((0.5f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1359 +fn c1341_l1359_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1341_l1359_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.5f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.07957747154594767f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1360 +fn c1342_l1360_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1342_l1360_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.5f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.07957747154594767f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1361 +fn c1343_l1361_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1343_l1361_action_invoke"); + let result = instance.call("div", &[Value::F64((0.5f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.07957747154594767f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1362 +fn c1344_l1362_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1344_l1362_action_invoke"); + let result = instance.call("div", &[Value::F64((0.5f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.07957747154594767f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1363 +fn c1345_l1363_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1345_l1363_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.5f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002781342323134f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1364 +fn c1346_l1364_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1346_l1364_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.5f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002781342323134f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1365 +fn c1347_l1365_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1347_l1365_action_invoke"); + let result = instance.call("div", &[Value::F64((0.5f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002781342323134f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1366 +fn c1348_l1366_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1348_l1366_action_invoke"); + let result = instance.call("div", &[Value::F64((0.5f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002781342323134f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1367 +fn c1349_l1367_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1349_l1367_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1368 +fn c1350_l1368_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1350_l1368_action_invoke"); + let result = instance.call("div", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1369 +fn c1351_l1369_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1351_l1369_action_invoke"); + let result = instance.call("div", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1370 +fn c1352_l1370_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1352_l1370_action_invoke"); + let result = instance.call("div", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1371 +fn c1353_l1371_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1353_l1371_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1353_l1371_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1372 +fn c1354_l1372_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1354_l1372_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1354_l1372_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1373 +fn c1355_l1373_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1355_l1373_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1355_l1373_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1374 +fn c1356_l1374_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1356_l1374_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1356_l1374_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1375 +fn c1357_l1375_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1357_l1375_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1357_l1375_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1376 +fn c1358_l1376_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1358_l1376_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1358_l1376_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1377 +fn c1359_l1377_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1359_l1377_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1359_l1377_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1378 +fn c1360_l1378_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1360_l1378_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1360_l1378_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1379 +fn c1361_l1379_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1361_l1379_action_invoke"); + let result = instance.call("div", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1380 +fn c1362_l1380_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1362_l1380_action_invoke"); + let result = instance.call("div", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1381 +fn c1363_l1381_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1363_l1381_action_invoke"); + let result = instance.call("div", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1382 +fn c1364_l1382_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1364_l1382_action_invoke"); + let result = instance.call("div", &[Value::F64((1.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1383 +fn c1365_l1383_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1365_l1383_action_invoke"); + let result = instance.call("div", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1384 +fn c1366_l1384_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1366_l1384_action_invoke"); + let result = instance.call("div", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1385 +fn c1367_l1385_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1367_l1385_action_invoke"); + let result = instance.call("div", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1386 +fn c1368_l1386_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1368_l1386_action_invoke"); + let result = instance.call("div", &[Value::F64((1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1387 +fn c1369_l1387_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1369_l1387_action_invoke"); + let result = instance.call("div", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((44942328371557900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1388 +fn c1370_l1388_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1370_l1388_action_invoke"); + let result = instance.call("div", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-44942328371557900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1389 +fn c1371_l1389_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1371_l1389_action_invoke"); + let result = instance.call("div", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-44942328371557900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1390 +fn c1372_l1390_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1372_l1390_action_invoke"); + let result = instance.call("div", &[Value::F64((1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((44942328371557900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1391 +fn c1373_l1391_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1373_l1391_action_invoke"); + let result = instance.call("div", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((2.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1392 +fn c1374_l1392_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1374_l1392_action_invoke"); + let result = instance.call("div", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-2.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1393 +fn c1375_l1393_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1375_l1393_action_invoke"); + let result = instance.call("div", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-2.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1394 +fn c1376_l1394_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1376_l1394_action_invoke"); + let result = instance.call("div", &[Value::F64((1.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((2.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1395 +fn c1377_l1395_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1377_l1395_action_invoke"); + let result = instance.call("div", &[Value::F64((-1.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1396 +fn c1378_l1396_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1378_l1396_action_invoke"); + let result = instance.call("div", &[Value::F64((-1.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1397 +fn c1379_l1397_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1379_l1397_action_invoke"); + let result = instance.call("div", &[Value::F64((1.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1398 +fn c1380_l1398_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1380_l1398_action_invoke"); + let result = instance.call("div", &[Value::F64((1.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1399 +fn c1381_l1399_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1381_l1399_action_invoke"); + let result = instance.call("div", &[Value::F64((-1.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.15915494309189535f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1400 +fn c1382_l1400_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1382_l1400_action_invoke"); + let result = instance.call("div", &[Value::F64((-1.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.15915494309189535f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1401 +fn c1383_l1401_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1383_l1401_action_invoke"); + let result = instance.call("div", &[Value::F64((1.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.15915494309189535f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1402 +fn c1384_l1402_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1384_l1402_action_invoke"); + let result = instance.call("div", &[Value::F64((1.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.15915494309189535f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1403 +fn c1385_l1403_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1385_l1403_action_invoke"); + let result = instance.call("div", &[Value::F64((-1.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005562684646268003f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1404 +fn c1386_l1404_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1386_l1404_action_invoke"); + let result = instance.call("div", &[Value::F64((-1.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005562684646268003f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1405 +fn c1387_l1405_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1387_l1405_action_invoke"); + let result = instance.call("div", &[Value::F64((1.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005562684646268003f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1406 +fn c1388_l1406_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1388_l1406_action_invoke"); + let result = instance.call("div", &[Value::F64((1.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005562684646268003f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1407 +fn c1389_l1407_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1389_l1407_action_invoke"); + let result = instance.call("div", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1408 +fn c1390_l1408_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1390_l1408_action_invoke"); + let result = instance.call("div", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1409 +fn c1391_l1409_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1391_l1409_action_invoke"); + let result = instance.call("div", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1410 +fn c1392_l1410_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1392_l1410_action_invoke"); + let result = instance.call("div", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1411 +fn c1393_l1411_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1393_l1411_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1393_l1411_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1412 +fn c1394_l1412_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1394_l1412_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1394_l1412_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1413 +fn c1395_l1413_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1395_l1413_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1395_l1413_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1414 +fn c1396_l1414_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1396_l1414_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1396_l1414_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1415 +fn c1397_l1415_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1397_l1415_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1397_l1415_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1416 +fn c1398_l1416_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1398_l1416_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1398_l1416_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1417 +fn c1399_l1417_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1399_l1417_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1399_l1417_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1418 +fn c1400_l1418_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1400_l1418_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1400_l1418_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1419 +fn c1401_l1419_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1401_l1419_action_invoke"); + let result = instance.call("div", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1420 +fn c1402_l1420_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1402_l1420_action_invoke"); + let result = instance.call("div", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1421 +fn c1403_l1421_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1403_l1421_action_invoke"); + let result = instance.call("div", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1422 +fn c1404_l1422_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1404_l1422_action_invoke"); + let result = instance.call("div", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1423 +fn c1405_l1423_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1405_l1423_action_invoke"); + let result = instance.call("div", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1424 +fn c1406_l1424_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1406_l1424_action_invoke"); + let result = instance.call("div", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1425 +fn c1407_l1425_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1407_l1425_action_invoke"); + let result = instance.call("div", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1426 +fn c1408_l1426_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1408_l1426_action_invoke"); + let result = instance.call("div", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1427 +fn c1409_l1427_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1409_l1427_action_invoke"); + let result = instance.call("div", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1428 +fn c1410_l1428_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1410_l1428_action_invoke"); + let result = instance.call("div", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1429 +fn c1411_l1429_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1411_l1429_action_invoke"); + let result = instance.call("div", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1430 +fn c1412_l1430_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1412_l1430_action_invoke"); + let result = instance.call("div", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1431 +fn c1413_l1431_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1413_l1431_action_invoke"); + let result = instance.call("div", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((12.566370614359172f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1432 +fn c1414_l1432_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1414_l1432_action_invoke"); + let result = instance.call("div", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-12.566370614359172f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1433 +fn c1415_l1433_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1415_l1433_action_invoke"); + let result = instance.call("div", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-12.566370614359172f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1434 +fn c1416_l1434_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1416_l1434_action_invoke"); + let result = instance.call("div", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((12.566370614359172f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1435 +fn c1417_l1435_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1417_l1435_action_invoke"); + let result = instance.call("div", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1436 +fn c1418_l1436_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1418_l1436_action_invoke"); + let result = instance.call("div", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1437 +fn c1419_l1437_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1419_l1437_action_invoke"); + let result = instance.call("div", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1438 +fn c1420_l1438_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1420_l1438_action_invoke"); + let result = instance.call("div", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1439 +fn c1421_l1439_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1421_l1439_action_invoke"); + let result = instance.call("div", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1440 +fn c1422_l1440_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1422_l1440_action_invoke"); + let result = instance.call("div", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1441 +fn c1423_l1441_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1423_l1441_action_invoke"); + let result = instance.call("div", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1442 +fn c1424_l1442_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1424_l1442_action_invoke"); + let result = instance.call("div", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1443 +fn c1425_l1443_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1425_l1443_action_invoke"); + let result = instance.call("div", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000349513784379046f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1444 +fn c1426_l1444_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1426_l1444_action_invoke"); + let result = instance.call("div", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000349513784379046f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1445 +fn c1427_l1445_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1427_l1445_action_invoke"); + let result = instance.call("div", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000349513784379046f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1446 +fn c1428_l1446_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1428_l1446_action_invoke"); + let result = instance.call("div", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000349513784379046f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1447 +fn c1429_l1447_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1429_l1447_action_invoke"); + let result = instance.call("div", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1448 +fn c1430_l1448_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1430_l1448_action_invoke"); + let result = instance.call("div", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1449 +fn c1431_l1449_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1431_l1449_action_invoke"); + let result = instance.call("div", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1450 +fn c1432_l1450_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1432_l1450_action_invoke"); + let result = instance.call("div", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1451 +fn c1433_l1451_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1433_l1451_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1433_l1451_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1452 +fn c1434_l1452_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1434_l1452_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1434_l1452_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1453 +fn c1435_l1453_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1435_l1453_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1435_l1453_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1454 +fn c1436_l1454_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1436_l1454_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1436_l1454_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1455 +fn c1437_l1455_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1437_l1455_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1437_l1455_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1456 +fn c1438_l1456_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1438_l1456_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1438_l1456_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1457 +fn c1439_l1457_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1439_l1457_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1439_l1457_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1458 +fn c1440_l1458_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1440_l1458_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1440_l1458_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1459 +fn c1441_l1459_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1441_l1459_action_invoke"); + let result = instance.call("div", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1460 +fn c1442_l1460_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1442_l1460_action_invoke"); + let result = instance.call("div", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1461 +fn c1443_l1461_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1443_l1461_action_invoke"); + let result = instance.call("div", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1462 +fn c1444_l1462_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1444_l1462_action_invoke"); + let result = instance.call("div", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1463 +fn c1445_l1463_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1445_l1463_action_invoke"); + let result = instance.call("div", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1464 +fn c1446_l1464_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1446_l1464_action_invoke"); + let result = instance.call("div", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1465 +fn c1447_l1465_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1447_l1465_action_invoke"); + let result = instance.call("div", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1466 +fn c1448_l1466_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1448_l1466_action_invoke"); + let result = instance.call("div", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1467 +fn c1449_l1467_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1449_l1467_action_invoke"); + let result = instance.call("div", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1468 +fn c1450_l1468_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1450_l1468_action_invoke"); + let result = instance.call("div", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1469 +fn c1451_l1469_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1451_l1469_action_invoke"); + let result = instance.call("div", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1470 +fn c1452_l1470_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1452_l1470_action_invoke"); + let result = instance.call("div", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1471 +fn c1453_l1471_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1453_l1471_action_invoke"); + let result = instance.call("div", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1472 +fn c1454_l1472_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1454_l1472_action_invoke"); + let result = instance.call("div", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1473 +fn c1455_l1473_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1455_l1473_action_invoke"); + let result = instance.call("div", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1474 +fn c1456_l1474_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1456_l1474_action_invoke"); + let result = instance.call("div", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1475 +fn c1457_l1475_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1457_l1475_action_invoke"); + let result = instance.call("div", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1476 +fn c1458_l1476_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1458_l1476_action_invoke"); + let result = instance.call("div", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1477 +fn c1459_l1477_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1459_l1477_action_invoke"); + let result = instance.call("div", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1478 +fn c1460_l1478_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1460_l1478_action_invoke"); + let result = instance.call("div", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1479 +fn c1461_l1479_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1461_l1479_action_invoke"); + let result = instance.call("div", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((28611174857570280000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1480 +fn c1462_l1480_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1462_l1480_action_invoke"); + let result = instance.call("div", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-28611174857570280000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1481 +fn c1463_l1481_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1463_l1481_action_invoke"); + let result = instance.call("div", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-28611174857570280000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1482 +fn c1464_l1482_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1464_l1482_action_invoke"); + let result = instance.call("div", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((28611174857570280000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1483 +fn c1465_l1483_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1465_l1483_action_invoke"); + let result = instance.call("div", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1484 +fn c1466_l1484_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1466_l1484_action_invoke"); + let result = instance.call("div", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1485 +fn c1467_l1485_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1467_l1485_action_invoke"); + let result = instance.call("div", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1486 +fn c1468_l1486_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1468_l1486_action_invoke"); + let result = instance.call("div", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1487 +fn c1469_l1487_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1469_l1487_action_invoke"); + let result = instance.call("div", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1488 +fn c1470_l1488_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1470_l1488_action_invoke"); + let result = instance.call("div", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1489 +fn c1471_l1489_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1471_l1489_action_invoke"); + let result = instance.call("div", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1490 +fn c1472_l1490_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1472_l1490_action_invoke"); + let result = instance.call("div", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1491 +fn c1473_l1491_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1473_l1491_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1473_l1491_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1492 +fn c1474_l1492_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1474_l1492_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1474_l1492_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1493 +fn c1475_l1493_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1475_l1493_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1475_l1493_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1494 +fn c1476_l1494_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1476_l1494_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1476_l1494_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1495 +fn c1477_l1495_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1477_l1495_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1477_l1495_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1496 +fn c1478_l1496_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1478_l1496_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1478_l1496_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1497 +fn c1479_l1497_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1479_l1497_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1479_l1497_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1498 +fn c1480_l1498_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1480_l1498_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1480_l1498_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1499 +fn c1481_l1499_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1481_l1499_action_invoke"); + let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1500 +fn c1482_l1500_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1482_l1500_action_invoke"); + let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1501 +fn c1483_l1501_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1483_l1501_action_invoke"); + let result = instance.call("div", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1502 +fn c1484_l1502_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1484_l1502_action_invoke"); + let result = instance.call("div", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1503 +fn c1485_l1503_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1485_l1503_action_invoke"); + let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1504 +fn c1486_l1504_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1486_l1504_action_invoke"); + let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1505 +fn c1487_l1505_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1487_l1505_action_invoke"); + let result = instance.call("div", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1506 +fn c1488_l1506_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1488_l1506_action_invoke"); + let result = instance.call("div", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1507 +fn c1489_l1507_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1489_l1507_action_invoke"); + let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1508 +fn c1490_l1508_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1490_l1508_action_invoke"); + let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1509 +fn c1491_l1509_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1491_l1509_action_invoke"); + let result = instance.call("div", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1510 +fn c1492_l1510_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1492_l1510_action_invoke"); + let result = instance.call("div", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1511 +fn c1493_l1511_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1493_l1511_action_invoke"); + let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1512 +fn c1494_l1512_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1494_l1512_action_invoke"); + let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1513 +fn c1495_l1513_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1495_l1513_action_invoke"); + let result = instance.call("div", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1514 +fn c1496_l1514_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1496_l1514_action_invoke"); + let result = instance.call("div", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1515 +fn c1497_l1515_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1497_l1515_action_invoke"); + let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1516 +fn c1498_l1516_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1498_l1516_action_invoke"); + let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1517 +fn c1499_l1517_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1499_l1517_action_invoke"); + let result = instance.call("div", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1518 +fn c1500_l1518_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1500_l1518_action_invoke"); + let result = instance.call("div", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1519 +fn c1501_l1519_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1501_l1519_action_invoke"); + let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1520 +fn c1502_l1520_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1502_l1520_action_invoke"); + let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1521 +fn c1503_l1521_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1503_l1521_action_invoke"); + let result = instance.call("div", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1522 +fn c1504_l1522_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1504_l1522_action_invoke"); + let result = instance.call("div", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1523 +fn c1505_l1523_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1505_l1523_action_invoke"); + let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1524 +fn c1506_l1524_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1506_l1524_action_invoke"); + let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1525 +fn c1507_l1525_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1507_l1525_action_invoke"); + let result = instance.call("div", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1526 +fn c1508_l1526_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1508_l1526_action_invoke"); + let result = instance.call("div", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1527 +fn c1509_l1527_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1509_l1527_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1509_l1527_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1528 +fn c1510_l1528_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1510_l1528_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::INFINITY.to_bits())]).unwrap().expect("Missing result in c1510_l1528_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1529 +fn c1511_l1529_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1511_l1529_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1511_l1529_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1530 +fn c1512_l1530_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1512_l1530_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::INFINITY.to_bits())]).unwrap().expect("Missing result in c1512_l1530_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1531 +fn c1513_l1531_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1513_l1531_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1513_l1531_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1532 +fn c1514_l1532_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1514_l1532_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1514_l1532_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1533 +fn c1515_l1533_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1515_l1533_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1515_l1533_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1534 +fn c1516_l1534_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1516_l1534_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1516_l1534_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1535 +fn c1517_l1535_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1517_l1535_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1517_l1535_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1536 +fn c1518_l1536_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1518_l1536_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1518_l1536_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1537 +fn c1519_l1537_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1519_l1537_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1519_l1537_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1538 +fn c1520_l1538_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1520_l1538_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1520_l1538_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1539 +fn c1521_l1539_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1521_l1539_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.0f64).to_bits())]).unwrap().expect("Missing result in c1521_l1539_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1540 +fn c1522_l1540_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1522_l1540_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.0f64).to_bits())]).unwrap().expect("Missing result in c1522_l1540_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1541 +fn c1523_l1541_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1523_l1541_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.0f64).to_bits())]).unwrap().expect("Missing result in c1523_l1541_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1542 +fn c1524_l1542_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1524_l1542_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.0f64).to_bits())]).unwrap().expect("Missing result in c1524_l1542_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1543 +fn c1525_l1543_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1525_l1543_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.0f64).to_bits())]).unwrap().expect("Missing result in c1525_l1543_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1544 +fn c1526_l1544_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1526_l1544_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.0f64).to_bits())]).unwrap().expect("Missing result in c1526_l1544_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1545 +fn c1527_l1545_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1527_l1545_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.0f64).to_bits())]).unwrap().expect("Missing result in c1527_l1545_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1546 +fn c1528_l1546_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1528_l1546_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.0f64).to_bits())]).unwrap().expect("Missing result in c1528_l1546_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1547 +fn c1529_l1547_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1529_l1547_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c1529_l1547_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1548 +fn c1530_l1548_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1530_l1548_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c1530_l1548_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1549 +fn c1531_l1549_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1531_l1549_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c1531_l1549_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1550 +fn c1532_l1550_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1532_l1550_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c1532_l1550_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1551 +fn c1533_l1551_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1533_l1551_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c1533_l1551_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1552 +fn c1534_l1552_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1534_l1552_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c1534_l1552_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1553 +fn c1535_l1553_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1535_l1553_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c1535_l1553_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1554 +fn c1536_l1554_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1536_l1554_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c1536_l1554_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1555 +fn c1537_l1555_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1537_l1555_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c1537_l1555_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1556 +fn c1538_l1556_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1538_l1556_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c1538_l1556_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1557 +fn c1539_l1557_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1539_l1557_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c1539_l1557_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1558 +fn c1540_l1558_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1540_l1558_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c1540_l1558_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1559 +fn c1541_l1559_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1541_l1559_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c1541_l1559_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1560 +fn c1542_l1560_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1542_l1560_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c1542_l1560_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1561 +fn c1543_l1561_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1543_l1561_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c1543_l1561_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1562 +fn c1544_l1562_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1544_l1562_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c1544_l1562_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1563 +fn c1545_l1563_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1545_l1563_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.5f64).to_bits())]).unwrap().expect("Missing result in c1545_l1563_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1564 +fn c1546_l1564_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1546_l1564_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.5f64).to_bits())]).unwrap().expect("Missing result in c1546_l1564_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1565 +fn c1547_l1565_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1547_l1565_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.5f64).to_bits())]).unwrap().expect("Missing result in c1547_l1565_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1566 +fn c1548_l1566_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1548_l1566_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.5f64).to_bits())]).unwrap().expect("Missing result in c1548_l1566_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1567 +fn c1549_l1567_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1549_l1567_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.5f64).to_bits())]).unwrap().expect("Missing result in c1549_l1567_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1568 +fn c1550_l1568_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1550_l1568_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.5f64).to_bits())]).unwrap().expect("Missing result in c1550_l1568_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1569 +fn c1551_l1569_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1551_l1569_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.5f64).to_bits())]).unwrap().expect("Missing result in c1551_l1569_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1570 +fn c1552_l1570_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1552_l1570_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.5f64).to_bits())]).unwrap().expect("Missing result in c1552_l1570_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1571 +fn c1553_l1571_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1553_l1571_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-1.0f64).to_bits())]).unwrap().expect("Missing result in c1553_l1571_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1572 +fn c1554_l1572_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1554_l1572_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-1.0f64).to_bits())]).unwrap().expect("Missing result in c1554_l1572_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1573 +fn c1555_l1573_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1555_l1573_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((1.0f64).to_bits())]).unwrap().expect("Missing result in c1555_l1573_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1574 +fn c1556_l1574_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1556_l1574_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((1.0f64).to_bits())]).unwrap().expect("Missing result in c1556_l1574_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1575 +fn c1557_l1575_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1557_l1575_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-1.0f64).to_bits())]).unwrap().expect("Missing result in c1557_l1575_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1576 +fn c1558_l1576_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1558_l1576_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-1.0f64).to_bits())]).unwrap().expect("Missing result in c1558_l1576_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1577 +fn c1559_l1577_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1559_l1577_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((1.0f64).to_bits())]).unwrap().expect("Missing result in c1559_l1577_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1578 +fn c1560_l1578_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1560_l1578_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((1.0f64).to_bits())]).unwrap().expect("Missing result in c1560_l1578_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1579 +fn c1561_l1579_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1561_l1579_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c1561_l1579_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1580 +fn c1562_l1580_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1562_l1580_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c1562_l1580_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1581 +fn c1563_l1581_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1563_l1581_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c1563_l1581_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1582 +fn c1564_l1582_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1564_l1582_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c1564_l1582_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1583 +fn c1565_l1583_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1565_l1583_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c1565_l1583_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1584 +fn c1566_l1584_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1566_l1584_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c1566_l1584_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1585 +fn c1567_l1585_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1567_l1585_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c1567_l1585_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1586 +fn c1568_l1586_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1568_l1586_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c1568_l1586_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1587 +fn c1569_l1587_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1569_l1587_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c1569_l1587_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1588 +fn c1570_l1588_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1570_l1588_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c1570_l1588_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1589 +fn c1571_l1589_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1571_l1589_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c1571_l1589_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1590 +fn c1572_l1590_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1572_l1590_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c1572_l1590_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1591 +fn c1573_l1591_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1573_l1591_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c1573_l1591_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1592 +fn c1574_l1592_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1574_l1592_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c1574_l1592_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1593 +fn c1575_l1593_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1575_l1593_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c1575_l1593_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1594 +fn c1576_l1594_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1576_l1594_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c1576_l1594_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1595 +fn c1577_l1595_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1577_l1595_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1577_l1595_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1596 +fn c1578_l1596_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1578_l1596_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1578_l1596_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1597 +fn c1579_l1597_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1579_l1597_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::INFINITY.to_bits())]).unwrap().expect("Missing result in c1579_l1597_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1598 +fn c1580_l1598_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1580_l1598_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::INFINITY.to_bits())]).unwrap().expect("Missing result in c1580_l1598_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1599 +fn c1581_l1599_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1581_l1599_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1581_l1599_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1600 +fn c1582_l1600_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1582_l1600_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1582_l1600_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1601 +fn c1583_l1601_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1583_l1601_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::INFINITY.to_bits())]).unwrap().expect("Missing result in c1583_l1601_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1602 +fn c1584_l1602_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1584_l1602_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::INFINITY.to_bits())]).unwrap().expect("Missing result in c1584_l1602_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1603 +fn c1585_l1603_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1585_l1603_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1585_l1603_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1604 +fn c1586_l1604_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1586_l1604_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1586_l1604_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1605 +fn c1587_l1605_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1587_l1605_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1587_l1605_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1606 +fn c1588_l1606_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1588_l1606_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1588_l1606_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1607 +fn c1589_l1607_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1589_l1607_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1589_l1607_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1608 +fn c1590_l1608_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1590_l1608_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1590_l1608_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1609 +fn c1591_l1609_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1591_l1609_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1591_l1609_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1610 +fn c1592_l1610_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1592_l1610_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1592_l1610_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1611 +fn c1593_l1611_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1593_l1611_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1593_l1611_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1612 +fn c1594_l1612_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1594_l1612_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1594_l1612_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1613 +fn c1595_l1613_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1595_l1613_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1595_l1613_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1614 +fn c1596_l1614_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1596_l1614_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1596_l1614_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1615 +fn c1597_l1615_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1597_l1615_assert_return_canonical_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1597_l1615_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1616 +fn c1598_l1616_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1598_l1616_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1598_l1616_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1617 +fn c1599_l1617_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1599_l1617_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1599_l1617_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1618 +fn c1600_l1618_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1600_l1618_assert_return_arithmetic_nan"); + let result = instance.call("div", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1600_l1618_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1619 +fn c1601_l1619_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1601_l1619_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1620 +fn c1602_l1620_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1602_l1620_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1621 +fn c1603_l1621_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1603_l1621_action_invoke"); + let result = instance.call("min", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1622 +fn c1604_l1622_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1604_l1622_action_invoke"); + let result = instance.call("min", &[Value::F64((0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1623 +fn c1605_l1623_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1605_l1623_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1624 +fn c1606_l1624_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1606_l1624_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1625 +fn c1607_l1625_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1607_l1625_action_invoke"); + let result = instance.call("min", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1626 +fn c1608_l1626_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1608_l1626_action_invoke"); + let result = instance.call("min", &[Value::F64((0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1627 +fn c1609_l1627_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1609_l1627_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1628 +fn c1610_l1628_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1610_l1628_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1629 +fn c1611_l1629_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1611_l1629_action_invoke"); + let result = instance.call("min", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1630 +fn c1612_l1630_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1612_l1630_action_invoke"); + let result = instance.call("min", &[Value::F64((0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1631 +fn c1613_l1631_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1613_l1631_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1632 +fn c1614_l1632_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1614_l1632_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1633 +fn c1615_l1633_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1615_l1633_action_invoke"); + let result = instance.call("min", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1634 +fn c1616_l1634_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1616_l1634_action_invoke"); + let result = instance.call("min", &[Value::F64((0.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1635 +fn c1617_l1635_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1617_l1635_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1636 +fn c1618_l1636_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1618_l1636_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1637 +fn c1619_l1637_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1619_l1637_action_invoke"); + let result = instance.call("min", &[Value::F64((0.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1638 +fn c1620_l1638_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1620_l1638_action_invoke"); + let result = instance.call("min", &[Value::F64((0.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1639 +fn c1621_l1639_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1621_l1639_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1640 +fn c1622_l1640_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1622_l1640_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1641 +fn c1623_l1641_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1623_l1641_action_invoke"); + let result = instance.call("min", &[Value::F64((0.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1642 +fn c1624_l1642_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1624_l1642_action_invoke"); + let result = instance.call("min", &[Value::F64((0.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1643 +fn c1625_l1643_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1625_l1643_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1644 +fn c1626_l1644_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1626_l1644_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1645 +fn c1627_l1645_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1627_l1645_action_invoke"); + let result = instance.call("min", &[Value::F64((0.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1646 +fn c1628_l1646_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1628_l1646_action_invoke"); + let result = instance.call("min", &[Value::F64((0.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1647 +fn c1629_l1647_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1629_l1647_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1648 +fn c1630_l1648_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1630_l1648_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1649 +fn c1631_l1649_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1631_l1649_action_invoke"); + let result = instance.call("min", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1650 +fn c1632_l1650_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1632_l1650_action_invoke"); + let result = instance.call("min", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1651 +fn c1633_l1651_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1633_l1651_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1633_l1651_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1652 +fn c1634_l1652_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1634_l1652_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1634_l1652_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1653 +fn c1635_l1653_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1635_l1653_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1635_l1653_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1654 +fn c1636_l1654_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1636_l1654_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1636_l1654_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1655 +fn c1637_l1655_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1637_l1655_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1637_l1655_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1656 +fn c1638_l1656_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1638_l1656_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1638_l1656_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1657 +fn c1639_l1657_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1639_l1657_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1639_l1657_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1658 +fn c1640_l1658_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1640_l1658_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1640_l1658_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1659 +fn c1641_l1659_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1641_l1659_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1660 +fn c1642_l1660_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1642_l1660_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1661 +fn c1643_l1661_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1643_l1661_action_invoke"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1662 +fn c1644_l1662_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1644_l1662_action_invoke"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1663 +fn c1645_l1663_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1645_l1663_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1664 +fn c1646_l1664_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1646_l1664_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1665 +fn c1647_l1665_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1647_l1665_action_invoke"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1666 +fn c1648_l1666_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1648_l1666_action_invoke"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1667 +fn c1649_l1667_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1649_l1667_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1668 +fn c1650_l1668_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1650_l1668_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1669 +fn c1651_l1669_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1651_l1669_action_invoke"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1670 +fn c1652_l1670_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1652_l1670_action_invoke"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1671 +fn c1653_l1671_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1653_l1671_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1672 +fn c1654_l1672_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1654_l1672_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1673 +fn c1655_l1673_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1655_l1673_action_invoke"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1674 +fn c1656_l1674_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1656_l1674_action_invoke"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1675 +fn c1657_l1675_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1657_l1675_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1676 +fn c1658_l1676_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1658_l1676_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1677 +fn c1659_l1677_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1659_l1677_action_invoke"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1678 +fn c1660_l1678_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1660_l1678_action_invoke"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1679 +fn c1661_l1679_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1661_l1679_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1680 +fn c1662_l1680_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1662_l1680_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1681 +fn c1663_l1681_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1663_l1681_action_invoke"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1682 +fn c1664_l1682_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1664_l1682_action_invoke"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1683 +fn c1665_l1683_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1665_l1683_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1684 +fn c1666_l1684_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1666_l1684_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1685 +fn c1667_l1685_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1667_l1685_action_invoke"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1686 +fn c1668_l1686_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1668_l1686_action_invoke"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1687 +fn c1669_l1687_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1669_l1687_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1688 +fn c1670_l1688_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1670_l1688_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1689 +fn c1671_l1689_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1671_l1689_action_invoke"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1690 +fn c1672_l1690_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1672_l1690_action_invoke"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1691 +fn c1673_l1691_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1673_l1691_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1673_l1691_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1692 +fn c1674_l1692_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1674_l1692_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1674_l1692_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1693 +fn c1675_l1693_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1675_l1693_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1675_l1693_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1694 +fn c1676_l1694_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1676_l1694_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1676_l1694_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1695 +fn c1677_l1695_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1677_l1695_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1677_l1695_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1696 +fn c1678_l1696_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1678_l1696_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1678_l1696_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1697 +fn c1679_l1697_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1679_l1697_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1679_l1697_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1698 +fn c1680_l1698_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1680_l1698_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1680_l1698_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1699 +fn c1681_l1699_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1681_l1699_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1700 +fn c1682_l1700_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1682_l1700_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1701 +fn c1683_l1701_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1683_l1701_action_invoke"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1702 +fn c1684_l1702_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1684_l1702_action_invoke"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1703 +fn c1685_l1703_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1685_l1703_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1704 +fn c1686_l1704_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1686_l1704_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1705 +fn c1687_l1705_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1687_l1705_action_invoke"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1706 +fn c1688_l1706_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1688_l1706_action_invoke"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1707 +fn c1689_l1707_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1689_l1707_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1708 +fn c1690_l1708_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1690_l1708_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1709 +fn c1691_l1709_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1691_l1709_action_invoke"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1710 +fn c1692_l1710_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1692_l1710_action_invoke"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1711 +fn c1693_l1711_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1693_l1711_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1712 +fn c1694_l1712_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1694_l1712_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1713 +fn c1695_l1713_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1695_l1713_action_invoke"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1714 +fn c1696_l1714_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1696_l1714_action_invoke"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1715 +fn c1697_l1715_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1697_l1715_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1716 +fn c1698_l1716_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1698_l1716_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1717 +fn c1699_l1717_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1699_l1717_action_invoke"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1718 +fn c1700_l1718_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1700_l1718_action_invoke"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1719 +fn c1701_l1719_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1701_l1719_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1720 +fn c1702_l1720_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1702_l1720_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1721 +fn c1703_l1721_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1703_l1721_action_invoke"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1722 +fn c1704_l1722_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1704_l1722_action_invoke"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1723 +fn c1705_l1723_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1705_l1723_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1724 +fn c1706_l1724_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1706_l1724_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1725 +fn c1707_l1725_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1707_l1725_action_invoke"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1726 +fn c1708_l1726_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1708_l1726_action_invoke"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1727 +fn c1709_l1727_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1709_l1727_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1728 +fn c1710_l1728_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1710_l1728_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1729 +fn c1711_l1729_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1711_l1729_action_invoke"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1730 +fn c1712_l1730_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1712_l1730_action_invoke"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1731 +fn c1713_l1731_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1713_l1731_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1713_l1731_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1732 +fn c1714_l1732_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1714_l1732_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1714_l1732_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1733 +fn c1715_l1733_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1715_l1733_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1715_l1733_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1734 +fn c1716_l1734_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1716_l1734_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1716_l1734_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1735 +fn c1717_l1735_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1717_l1735_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1717_l1735_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1736 +fn c1718_l1736_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1718_l1736_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1718_l1736_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1737 +fn c1719_l1737_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1719_l1737_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1719_l1737_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1738 +fn c1720_l1738_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1720_l1738_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1720_l1738_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1739 +fn c1721_l1739_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1721_l1739_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1740 +fn c1722_l1740_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1722_l1740_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1741 +fn c1723_l1741_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1723_l1741_action_invoke"); + let result = instance.call("min", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1742 +fn c1724_l1742_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1724_l1742_action_invoke"); + let result = instance.call("min", &[Value::F64((0.5f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1743 +fn c1725_l1743_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1725_l1743_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1744 +fn c1726_l1744_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1726_l1744_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1745 +fn c1727_l1745_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1727_l1745_action_invoke"); + let result = instance.call("min", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1746 +fn c1728_l1746_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1728_l1746_action_invoke"); + let result = instance.call("min", &[Value::F64((0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1747 +fn c1729_l1747_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1729_l1747_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1748 +fn c1730_l1748_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1730_l1748_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1749 +fn c1731_l1749_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1731_l1749_action_invoke"); + let result = instance.call("min", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1750 +fn c1732_l1750_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1732_l1750_action_invoke"); + let result = instance.call("min", &[Value::F64((0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1751 +fn c1733_l1751_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1733_l1751_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1752 +fn c1734_l1752_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1734_l1752_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1753 +fn c1735_l1753_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1735_l1753_action_invoke"); + let result = instance.call("min", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1754 +fn c1736_l1754_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1736_l1754_action_invoke"); + let result = instance.call("min", &[Value::F64((0.5f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1755 +fn c1737_l1755_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1737_l1755_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.5f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1756 +fn c1738_l1756_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1738_l1756_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.5f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1757 +fn c1739_l1757_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1739_l1757_action_invoke"); + let result = instance.call("min", &[Value::F64((0.5f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1758 +fn c1740_l1758_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1740_l1758_action_invoke"); + let result = instance.call("min", &[Value::F64((0.5f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1759 +fn c1741_l1759_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1741_l1759_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.5f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1760 +fn c1742_l1760_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1742_l1760_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.5f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1761 +fn c1743_l1761_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1743_l1761_action_invoke"); + let result = instance.call("min", &[Value::F64((0.5f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1762 +fn c1744_l1762_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1744_l1762_action_invoke"); + let result = instance.call("min", &[Value::F64((0.5f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1763 +fn c1745_l1763_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1745_l1763_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.5f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1764 +fn c1746_l1764_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1746_l1764_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.5f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1765 +fn c1747_l1765_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1747_l1765_action_invoke"); + let result = instance.call("min", &[Value::F64((0.5f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1766 +fn c1748_l1766_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1748_l1766_action_invoke"); + let result = instance.call("min", &[Value::F64((0.5f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1767 +fn c1749_l1767_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1749_l1767_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1768 +fn c1750_l1768_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1750_l1768_action_invoke"); + let result = instance.call("min", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1769 +fn c1751_l1769_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1751_l1769_action_invoke"); + let result = instance.call("min", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1770 +fn c1752_l1770_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1752_l1770_action_invoke"); + let result = instance.call("min", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1771 +fn c1753_l1771_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1753_l1771_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1753_l1771_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1772 +fn c1754_l1772_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1754_l1772_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1754_l1772_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1773 +fn c1755_l1773_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1755_l1773_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1755_l1773_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1774 +fn c1756_l1774_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1756_l1774_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1756_l1774_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1775 +fn c1757_l1775_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1757_l1775_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1757_l1775_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1776 +fn c1758_l1776_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1758_l1776_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1758_l1776_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1777 +fn c1759_l1777_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1759_l1777_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1759_l1777_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1778 +fn c1760_l1778_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1760_l1778_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1760_l1778_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1779 +fn c1761_l1779_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1761_l1779_action_invoke"); + let result = instance.call("min", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1780 +fn c1762_l1780_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1762_l1780_action_invoke"); + let result = instance.call("min", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1781 +fn c1763_l1781_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1763_l1781_action_invoke"); + let result = instance.call("min", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1782 +fn c1764_l1782_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1764_l1782_action_invoke"); + let result = instance.call("min", &[Value::F64((1.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1783 +fn c1765_l1783_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1765_l1783_action_invoke"); + let result = instance.call("min", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1784 +fn c1766_l1784_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1766_l1784_action_invoke"); + let result = instance.call("min", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1785 +fn c1767_l1785_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1767_l1785_action_invoke"); + let result = instance.call("min", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1786 +fn c1768_l1786_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1768_l1786_action_invoke"); + let result = instance.call("min", &[Value::F64((1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1787 +fn c1769_l1787_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1769_l1787_action_invoke"); + let result = instance.call("min", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1788 +fn c1770_l1788_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1770_l1788_action_invoke"); + let result = instance.call("min", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1789 +fn c1771_l1789_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1771_l1789_action_invoke"); + let result = instance.call("min", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1790 +fn c1772_l1790_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1772_l1790_action_invoke"); + let result = instance.call("min", &[Value::F64((1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1791 +fn c1773_l1791_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1773_l1791_action_invoke"); + let result = instance.call("min", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1792 +fn c1774_l1792_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1774_l1792_action_invoke"); + let result = instance.call("min", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1793 +fn c1775_l1793_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1775_l1793_action_invoke"); + let result = instance.call("min", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1794 +fn c1776_l1794_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1776_l1794_action_invoke"); + let result = instance.call("min", &[Value::F64((1.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1795 +fn c1777_l1795_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1777_l1795_action_invoke"); + let result = instance.call("min", &[Value::F64((-1.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1796 +fn c1778_l1796_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1778_l1796_action_invoke"); + let result = instance.call("min", &[Value::F64((-1.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1797 +fn c1779_l1797_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1779_l1797_action_invoke"); + let result = instance.call("min", &[Value::F64((1.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1798 +fn c1780_l1798_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1780_l1798_action_invoke"); + let result = instance.call("min", &[Value::F64((1.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1799 +fn c1781_l1799_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1781_l1799_action_invoke"); + let result = instance.call("min", &[Value::F64((-1.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1800 +fn c1782_l1800_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1782_l1800_action_invoke"); + let result = instance.call("min", &[Value::F64((-1.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1801 +fn c1783_l1801_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1783_l1801_action_invoke"); + let result = instance.call("min", &[Value::F64((1.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1802 +fn c1784_l1802_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1784_l1802_action_invoke"); + let result = instance.call("min", &[Value::F64((1.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1803 +fn c1785_l1803_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1785_l1803_action_invoke"); + let result = instance.call("min", &[Value::F64((-1.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1804 +fn c1786_l1804_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1786_l1804_action_invoke"); + let result = instance.call("min", &[Value::F64((-1.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1805 +fn c1787_l1805_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1787_l1805_action_invoke"); + let result = instance.call("min", &[Value::F64((1.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1806 +fn c1788_l1806_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1788_l1806_action_invoke"); + let result = instance.call("min", &[Value::F64((1.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1807 +fn c1789_l1807_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1789_l1807_action_invoke"); + let result = instance.call("min", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1808 +fn c1790_l1808_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1790_l1808_action_invoke"); + let result = instance.call("min", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1809 +fn c1791_l1809_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1791_l1809_action_invoke"); + let result = instance.call("min", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1810 +fn c1792_l1810_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1792_l1810_action_invoke"); + let result = instance.call("min", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1811 +fn c1793_l1811_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1793_l1811_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1793_l1811_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1812 +fn c1794_l1812_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1794_l1812_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1794_l1812_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1813 +fn c1795_l1813_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1795_l1813_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1795_l1813_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1814 +fn c1796_l1814_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1796_l1814_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1796_l1814_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1815 +fn c1797_l1815_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1797_l1815_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1797_l1815_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1816 +fn c1798_l1816_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1798_l1816_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1798_l1816_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1817 +fn c1799_l1817_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1799_l1817_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1799_l1817_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1818 +fn c1800_l1818_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1800_l1818_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1800_l1818_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1819 +fn c1801_l1819_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1801_l1819_action_invoke"); + let result = instance.call("min", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1820 +fn c1802_l1820_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1802_l1820_action_invoke"); + let result = instance.call("min", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1821 +fn c1803_l1821_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1803_l1821_action_invoke"); + let result = instance.call("min", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1822 +fn c1804_l1822_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1804_l1822_action_invoke"); + let result = instance.call("min", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1823 +fn c1805_l1823_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1805_l1823_action_invoke"); + let result = instance.call("min", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1824 +fn c1806_l1824_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1806_l1824_action_invoke"); + let result = instance.call("min", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1825 +fn c1807_l1825_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1807_l1825_action_invoke"); + let result = instance.call("min", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1826 +fn c1808_l1826_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1808_l1826_action_invoke"); + let result = instance.call("min", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1827 +fn c1809_l1827_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1809_l1827_action_invoke"); + let result = instance.call("min", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1828 +fn c1810_l1828_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1810_l1828_action_invoke"); + let result = instance.call("min", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1829 +fn c1811_l1829_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1811_l1829_action_invoke"); + let result = instance.call("min", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1830 +fn c1812_l1830_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1812_l1830_action_invoke"); + let result = instance.call("min", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1831 +fn c1813_l1831_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1813_l1831_action_invoke"); + let result = instance.call("min", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1832 +fn c1814_l1832_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1814_l1832_action_invoke"); + let result = instance.call("min", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1833 +fn c1815_l1833_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1815_l1833_action_invoke"); + let result = instance.call("min", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1834 +fn c1816_l1834_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1816_l1834_action_invoke"); + let result = instance.call("min", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1835 +fn c1817_l1835_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1817_l1835_action_invoke"); + let result = instance.call("min", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1836 +fn c1818_l1836_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1818_l1836_action_invoke"); + let result = instance.call("min", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1837 +fn c1819_l1837_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1819_l1837_action_invoke"); + let result = instance.call("min", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1838 +fn c1820_l1838_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1820_l1838_action_invoke"); + let result = instance.call("min", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1839 +fn c1821_l1839_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1821_l1839_action_invoke"); + let result = instance.call("min", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1840 +fn c1822_l1840_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1822_l1840_action_invoke"); + let result = instance.call("min", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1841 +fn c1823_l1841_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1823_l1841_action_invoke"); + let result = instance.call("min", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1842 +fn c1824_l1842_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1824_l1842_action_invoke"); + let result = instance.call("min", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1843 +fn c1825_l1843_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1825_l1843_action_invoke"); + let result = instance.call("min", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1844 +fn c1826_l1844_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1826_l1844_action_invoke"); + let result = instance.call("min", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1845 +fn c1827_l1845_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1827_l1845_action_invoke"); + let result = instance.call("min", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1846 +fn c1828_l1846_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1828_l1846_action_invoke"); + let result = instance.call("min", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1847 +fn c1829_l1847_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1829_l1847_action_invoke"); + let result = instance.call("min", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1848 +fn c1830_l1848_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1830_l1848_action_invoke"); + let result = instance.call("min", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1849 +fn c1831_l1849_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1831_l1849_action_invoke"); + let result = instance.call("min", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1850 +fn c1832_l1850_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1832_l1850_action_invoke"); + let result = instance.call("min", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1851 +fn c1833_l1851_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1833_l1851_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1833_l1851_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1852 +fn c1834_l1852_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1834_l1852_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1834_l1852_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1853 +fn c1835_l1853_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1835_l1853_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1835_l1853_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1854 +fn c1836_l1854_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1836_l1854_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1836_l1854_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1855 +fn c1837_l1855_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1837_l1855_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1837_l1855_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1856 +fn c1838_l1856_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1838_l1856_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1838_l1856_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1857 +fn c1839_l1857_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1839_l1857_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1839_l1857_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1858 +fn c1840_l1858_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1840_l1858_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1840_l1858_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1859 +fn c1841_l1859_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1841_l1859_action_invoke"); + let result = instance.call("min", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1860 +fn c1842_l1860_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1842_l1860_action_invoke"); + let result = instance.call("min", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1861 +fn c1843_l1861_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1843_l1861_action_invoke"); + let result = instance.call("min", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1862 +fn c1844_l1862_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1844_l1862_action_invoke"); + let result = instance.call("min", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1863 +fn c1845_l1863_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1845_l1863_action_invoke"); + let result = instance.call("min", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1864 +fn c1846_l1864_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1846_l1864_action_invoke"); + let result = instance.call("min", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1865 +fn c1847_l1865_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1847_l1865_action_invoke"); + let result = instance.call("min", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1866 +fn c1848_l1866_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1848_l1866_action_invoke"); + let result = instance.call("min", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1867 +fn c1849_l1867_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1849_l1867_action_invoke"); + let result = instance.call("min", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1868 +fn c1850_l1868_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1850_l1868_action_invoke"); + let result = instance.call("min", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1869 +fn c1851_l1869_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1851_l1869_action_invoke"); + let result = instance.call("min", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1870 +fn c1852_l1870_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1852_l1870_action_invoke"); + let result = instance.call("min", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1871 +fn c1853_l1871_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1853_l1871_action_invoke"); + let result = instance.call("min", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1872 +fn c1854_l1872_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1854_l1872_action_invoke"); + let result = instance.call("min", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1873 +fn c1855_l1873_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1855_l1873_action_invoke"); + let result = instance.call("min", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1874 +fn c1856_l1874_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1856_l1874_action_invoke"); + let result = instance.call("min", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1875 +fn c1857_l1875_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1857_l1875_action_invoke"); + let result = instance.call("min", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1876 +fn c1858_l1876_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1858_l1876_action_invoke"); + let result = instance.call("min", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1877 +fn c1859_l1877_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1859_l1877_action_invoke"); + let result = instance.call("min", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1878 +fn c1860_l1878_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1860_l1878_action_invoke"); + let result = instance.call("min", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1879 +fn c1861_l1879_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1861_l1879_action_invoke"); + let result = instance.call("min", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1880 +fn c1862_l1880_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1862_l1880_action_invoke"); + let result = instance.call("min", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1881 +fn c1863_l1881_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1863_l1881_action_invoke"); + let result = instance.call("min", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1882 +fn c1864_l1882_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1864_l1882_action_invoke"); + let result = instance.call("min", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1883 +fn c1865_l1883_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1865_l1883_action_invoke"); + let result = instance.call("min", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1884 +fn c1866_l1884_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1866_l1884_action_invoke"); + let result = instance.call("min", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1885 +fn c1867_l1885_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1867_l1885_action_invoke"); + let result = instance.call("min", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1886 +fn c1868_l1886_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1868_l1886_action_invoke"); + let result = instance.call("min", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1887 +fn c1869_l1887_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1869_l1887_action_invoke"); + let result = instance.call("min", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1888 +fn c1870_l1888_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1870_l1888_action_invoke"); + let result = instance.call("min", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1889 +fn c1871_l1889_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1871_l1889_action_invoke"); + let result = instance.call("min", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1890 +fn c1872_l1890_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1872_l1890_action_invoke"); + let result = instance.call("min", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1891 +fn c1873_l1891_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1873_l1891_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1873_l1891_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1892 +fn c1874_l1892_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1874_l1892_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1874_l1892_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1893 +fn c1875_l1893_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1875_l1893_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1875_l1893_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1894 +fn c1876_l1894_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1876_l1894_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1876_l1894_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1895 +fn c1877_l1895_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1877_l1895_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1877_l1895_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1896 +fn c1878_l1896_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1878_l1896_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1878_l1896_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1897 +fn c1879_l1897_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1879_l1897_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1879_l1897_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1898 +fn c1880_l1898_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1880_l1898_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1880_l1898_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1899 +fn c1881_l1899_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1881_l1899_action_invoke"); + let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1900 +fn c1882_l1900_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1882_l1900_action_invoke"); + let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1901 +fn c1883_l1901_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1883_l1901_action_invoke"); + let result = instance.call("min", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1902 +fn c1884_l1902_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1884_l1902_action_invoke"); + let result = instance.call("min", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1903 +fn c1885_l1903_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1885_l1903_action_invoke"); + let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1904 +fn c1886_l1904_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1886_l1904_action_invoke"); + let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1905 +fn c1887_l1905_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1887_l1905_action_invoke"); + let result = instance.call("min", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1906 +fn c1888_l1906_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1888_l1906_action_invoke"); + let result = instance.call("min", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1907 +fn c1889_l1907_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1889_l1907_action_invoke"); + let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1908 +fn c1890_l1908_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1890_l1908_action_invoke"); + let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1909 +fn c1891_l1909_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1891_l1909_action_invoke"); + let result = instance.call("min", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1910 +fn c1892_l1910_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1892_l1910_action_invoke"); + let result = instance.call("min", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1911 +fn c1893_l1911_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1893_l1911_action_invoke"); + let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1912 +fn c1894_l1912_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1894_l1912_action_invoke"); + let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1913 +fn c1895_l1913_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1895_l1913_action_invoke"); + let result = instance.call("min", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1914 +fn c1896_l1914_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1896_l1914_action_invoke"); + let result = instance.call("min", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1915 +fn c1897_l1915_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1897_l1915_action_invoke"); + let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1916 +fn c1898_l1916_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1898_l1916_action_invoke"); + let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1917 +fn c1899_l1917_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1899_l1917_action_invoke"); + let result = instance.call("min", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1918 +fn c1900_l1918_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1900_l1918_action_invoke"); + let result = instance.call("min", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1919 +fn c1901_l1919_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1901_l1919_action_invoke"); + let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1920 +fn c1902_l1920_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1902_l1920_action_invoke"); + let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1921 +fn c1903_l1921_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1903_l1921_action_invoke"); + let result = instance.call("min", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1922 +fn c1904_l1922_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1904_l1922_action_invoke"); + let result = instance.call("min", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1923 +fn c1905_l1923_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1905_l1923_action_invoke"); + let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1924 +fn c1906_l1924_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1906_l1924_action_invoke"); + let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1925 +fn c1907_l1925_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1907_l1925_action_invoke"); + let result = instance.call("min", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1926 +fn c1908_l1926_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1908_l1926_action_invoke"); + let result = instance.call("min", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1927 +fn c1909_l1927_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1909_l1927_action_invoke"); + let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1928 +fn c1910_l1928_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1910_l1928_action_invoke"); + let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1929 +fn c1911_l1929_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1911_l1929_action_invoke"); + let result = instance.call("min", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1930 +fn c1912_l1930_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1912_l1930_action_invoke"); + let result = instance.call("min", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1931 +fn c1913_l1931_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1913_l1931_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1913_l1931_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1932 +fn c1914_l1932_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1914_l1932_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1914_l1932_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1933 +fn c1915_l1933_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1915_l1933_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1915_l1933_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1934 +fn c1916_l1934_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1916_l1934_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1916_l1934_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1935 +fn c1917_l1935_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1917_l1935_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1917_l1935_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1936 +fn c1918_l1936_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1918_l1936_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1918_l1936_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1937 +fn c1919_l1937_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1919_l1937_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1919_l1937_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1938 +fn c1920_l1938_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1920_l1938_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1920_l1938_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1939 +fn c1921_l1939_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1921_l1939_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.0f64).to_bits())]).unwrap().expect("Missing result in c1921_l1939_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1940 +fn c1922_l1940_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1922_l1940_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.0f64).to_bits())]).unwrap().expect("Missing result in c1922_l1940_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1941 +fn c1923_l1941_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1923_l1941_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.0f64).to_bits())]).unwrap().expect("Missing result in c1923_l1941_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1942 +fn c1924_l1942_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1924_l1942_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.0f64).to_bits())]).unwrap().expect("Missing result in c1924_l1942_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1943 +fn c1925_l1943_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1925_l1943_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.0f64).to_bits())]).unwrap().expect("Missing result in c1925_l1943_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1944 +fn c1926_l1944_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1926_l1944_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.0f64).to_bits())]).unwrap().expect("Missing result in c1926_l1944_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1945 +fn c1927_l1945_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1927_l1945_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.0f64).to_bits())]).unwrap().expect("Missing result in c1927_l1945_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1946 +fn c1928_l1946_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1928_l1946_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.0f64).to_bits())]).unwrap().expect("Missing result in c1928_l1946_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1947 +fn c1929_l1947_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1929_l1947_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c1929_l1947_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1948 +fn c1930_l1948_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1930_l1948_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c1930_l1948_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1949 +fn c1931_l1949_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1931_l1949_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c1931_l1949_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1950 +fn c1932_l1950_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1932_l1950_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c1932_l1950_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1951 +fn c1933_l1951_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1933_l1951_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c1933_l1951_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1952 +fn c1934_l1952_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1934_l1952_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c1934_l1952_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1953 +fn c1935_l1953_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1935_l1953_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c1935_l1953_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1954 +fn c1936_l1954_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1936_l1954_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c1936_l1954_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1955 +fn c1937_l1955_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1937_l1955_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c1937_l1955_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1956 +fn c1938_l1956_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1938_l1956_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c1938_l1956_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1957 +fn c1939_l1957_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1939_l1957_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c1939_l1957_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1958 +fn c1940_l1958_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1940_l1958_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c1940_l1958_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1959 +fn c1941_l1959_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1941_l1959_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c1941_l1959_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1960 +fn c1942_l1960_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1942_l1960_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c1942_l1960_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1961 +fn c1943_l1961_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1943_l1961_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c1943_l1961_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1962 +fn c1944_l1962_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1944_l1962_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c1944_l1962_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1963 +fn c1945_l1963_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1945_l1963_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.5f64).to_bits())]).unwrap().expect("Missing result in c1945_l1963_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1964 +fn c1946_l1964_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1946_l1964_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.5f64).to_bits())]).unwrap().expect("Missing result in c1946_l1964_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1965 +fn c1947_l1965_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1947_l1965_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.5f64).to_bits())]).unwrap().expect("Missing result in c1947_l1965_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1966 +fn c1948_l1966_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1948_l1966_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.5f64).to_bits())]).unwrap().expect("Missing result in c1948_l1966_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1967 +fn c1949_l1967_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1949_l1967_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.5f64).to_bits())]).unwrap().expect("Missing result in c1949_l1967_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1968 +fn c1950_l1968_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1950_l1968_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.5f64).to_bits())]).unwrap().expect("Missing result in c1950_l1968_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1969 +fn c1951_l1969_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1951_l1969_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.5f64).to_bits())]).unwrap().expect("Missing result in c1951_l1969_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1970 +fn c1952_l1970_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1952_l1970_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.5f64).to_bits())]).unwrap().expect("Missing result in c1952_l1970_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1971 +fn c1953_l1971_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1953_l1971_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-1.0f64).to_bits())]).unwrap().expect("Missing result in c1953_l1971_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1972 +fn c1954_l1972_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1954_l1972_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-1.0f64).to_bits())]).unwrap().expect("Missing result in c1954_l1972_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1973 +fn c1955_l1973_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1955_l1973_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((1.0f64).to_bits())]).unwrap().expect("Missing result in c1955_l1973_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1974 +fn c1956_l1974_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1956_l1974_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((1.0f64).to_bits())]).unwrap().expect("Missing result in c1956_l1974_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1975 +fn c1957_l1975_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1957_l1975_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-1.0f64).to_bits())]).unwrap().expect("Missing result in c1957_l1975_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1976 +fn c1958_l1976_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1958_l1976_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-1.0f64).to_bits())]).unwrap().expect("Missing result in c1958_l1976_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1977 +fn c1959_l1977_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1959_l1977_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((1.0f64).to_bits())]).unwrap().expect("Missing result in c1959_l1977_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1978 +fn c1960_l1978_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1960_l1978_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((1.0f64).to_bits())]).unwrap().expect("Missing result in c1960_l1978_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1979 +fn c1961_l1979_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1961_l1979_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c1961_l1979_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1980 +fn c1962_l1980_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1962_l1980_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c1962_l1980_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1981 +fn c1963_l1981_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1963_l1981_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c1963_l1981_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1982 +fn c1964_l1982_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1964_l1982_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c1964_l1982_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1983 +fn c1965_l1983_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1965_l1983_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c1965_l1983_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1984 +fn c1966_l1984_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1966_l1984_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c1966_l1984_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1985 +fn c1967_l1985_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1967_l1985_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c1967_l1985_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1986 +fn c1968_l1986_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1968_l1986_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c1968_l1986_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1987 +fn c1969_l1987_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1969_l1987_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c1969_l1987_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1988 +fn c1970_l1988_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1970_l1988_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c1970_l1988_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1989 +fn c1971_l1989_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1971_l1989_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c1971_l1989_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1990 +fn c1972_l1990_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1972_l1990_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c1972_l1990_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1991 +fn c1973_l1991_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1973_l1991_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c1973_l1991_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1992 +fn c1974_l1992_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1974_l1992_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c1974_l1992_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1993 +fn c1975_l1993_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1975_l1993_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c1975_l1993_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1994 +fn c1976_l1994_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1976_l1994_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c1976_l1994_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1995 +fn c1977_l1995_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1977_l1995_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1977_l1995_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1996 +fn c1978_l1996_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1978_l1996_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1978_l1996_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1997 +fn c1979_l1997_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1979_l1997_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::INFINITY.to_bits())]).unwrap().expect("Missing result in c1979_l1997_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1998 +fn c1980_l1998_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1980_l1998_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::INFINITY.to_bits())]).unwrap().expect("Missing result in c1980_l1998_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1999 +fn c1981_l1999_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1981_l1999_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1981_l1999_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2000 +fn c1982_l2000_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1982_l2000_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c1982_l2000_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2001 +fn c1983_l2001_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1983_l2001_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::INFINITY.to_bits())]).unwrap().expect("Missing result in c1983_l2001_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2002 +fn c1984_l2002_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1984_l2002_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::INFINITY.to_bits())]).unwrap().expect("Missing result in c1984_l2002_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2003 +fn c1985_l2003_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1985_l2003_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1985_l2003_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2004 +fn c1986_l2004_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1986_l2004_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1986_l2004_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2005 +fn c1987_l2005_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1987_l2005_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1987_l2005_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2006 +fn c1988_l2006_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1988_l2006_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1988_l2006_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2007 +fn c1989_l2007_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1989_l2007_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1989_l2007_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2008 +fn c1990_l2008_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1990_l2008_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1990_l2008_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2009 +fn c1991_l2009_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1991_l2009_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1991_l2009_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2010 +fn c1992_l2010_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1992_l2010_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1992_l2010_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2011 +fn c1993_l2011_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1993_l2011_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1993_l2011_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2012 +fn c1994_l2012_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1994_l2012_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c1994_l2012_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2013 +fn c1995_l2013_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1995_l2013_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1995_l2013_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2014 +fn c1996_l2014_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1996_l2014_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c1996_l2014_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2015 +fn c1997_l2015_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c1997_l2015_assert_return_canonical_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1997_l2015_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2016 +fn c1998_l2016_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1998_l2016_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c1998_l2016_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2017 +fn c1999_l2017_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c1999_l2017_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c1999_l2017_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2018 +fn c2000_l2018_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2000_l2018_assert_return_arithmetic_nan"); + let result = instance.call("min", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c2000_l2018_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2019 +fn c2001_l2019_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2001_l2019_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2020 +fn c2002_l2020_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2002_l2020_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2021 +fn c2003_l2021_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2003_l2021_action_invoke"); + let result = instance.call("max", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2022 +fn c2004_l2022_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2004_l2022_action_invoke"); + let result = instance.call("max", &[Value::F64((0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2023 +fn c2005_l2023_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2005_l2023_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2024 +fn c2006_l2024_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2006_l2024_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2025 +fn c2007_l2025_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2007_l2025_action_invoke"); + let result = instance.call("max", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2026 +fn c2008_l2026_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2008_l2026_action_invoke"); + let result = instance.call("max", &[Value::F64((0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2027 +fn c2009_l2027_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2009_l2027_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2028 +fn c2010_l2028_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2010_l2028_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2029 +fn c2011_l2029_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2011_l2029_action_invoke"); + let result = instance.call("max", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2030 +fn c2012_l2030_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2012_l2030_action_invoke"); + let result = instance.call("max", &[Value::F64((0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2031 +fn c2013_l2031_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2013_l2031_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2032 +fn c2014_l2032_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2014_l2032_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2033 +fn c2015_l2033_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2015_l2033_action_invoke"); + let result = instance.call("max", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2034 +fn c2016_l2034_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2016_l2034_action_invoke"); + let result = instance.call("max", &[Value::F64((0.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2035 +fn c2017_l2035_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2017_l2035_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2036 +fn c2018_l2036_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2018_l2036_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2037 +fn c2019_l2037_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2019_l2037_action_invoke"); + let result = instance.call("max", &[Value::F64((0.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2038 +fn c2020_l2038_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2020_l2038_action_invoke"); + let result = instance.call("max", &[Value::F64((0.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2039 +fn c2021_l2039_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2021_l2039_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2040 +fn c2022_l2040_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2022_l2040_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2041 +fn c2023_l2041_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2023_l2041_action_invoke"); + let result = instance.call("max", &[Value::F64((0.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2042 +fn c2024_l2042_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2024_l2042_action_invoke"); + let result = instance.call("max", &[Value::F64((0.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2043 +fn c2025_l2043_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2025_l2043_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2044 +fn c2026_l2044_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2026_l2044_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2045 +fn c2027_l2045_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2027_l2045_action_invoke"); + let result = instance.call("max", &[Value::F64((0.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2046 +fn c2028_l2046_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2028_l2046_action_invoke"); + let result = instance.call("max", &[Value::F64((0.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2047 +fn c2029_l2047_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2029_l2047_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2048 +fn c2030_l2048_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2030_l2048_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2049 +fn c2031_l2049_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2031_l2049_action_invoke"); + let result = instance.call("max", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2050 +fn c2032_l2050_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2032_l2050_action_invoke"); + let result = instance.call("max", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2051 +fn c2033_l2051_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2033_l2051_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c2033_l2051_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2052 +fn c2034_l2052_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2034_l2052_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c2034_l2052_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2053 +fn c2035_l2053_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2035_l2053_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c2035_l2053_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2054 +fn c2036_l2054_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2036_l2054_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c2036_l2054_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2055 +fn c2037_l2055_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2037_l2055_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c2037_l2055_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2056 +fn c2038_l2056_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2038_l2056_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c2038_l2056_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2057 +fn c2039_l2057_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2039_l2057_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c2039_l2057_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2058 +fn c2040_l2058_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2040_l2058_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c2040_l2058_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2059 +fn c2041_l2059_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2041_l2059_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2060 +fn c2042_l2060_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2042_l2060_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2061 +fn c2043_l2061_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2043_l2061_action_invoke"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2062 +fn c2044_l2062_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2044_l2062_action_invoke"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2063 +fn c2045_l2063_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2045_l2063_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2064 +fn c2046_l2064_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2046_l2064_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2065 +fn c2047_l2065_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2047_l2065_action_invoke"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2066 +fn c2048_l2066_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2048_l2066_action_invoke"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2067 +fn c2049_l2067_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2049_l2067_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2068 +fn c2050_l2068_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2050_l2068_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2069 +fn c2051_l2069_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2051_l2069_action_invoke"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2070 +fn c2052_l2070_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2052_l2070_action_invoke"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2071 +fn c2053_l2071_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2053_l2071_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2072 +fn c2054_l2072_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2054_l2072_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2073 +fn c2055_l2073_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2055_l2073_action_invoke"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2074 +fn c2056_l2074_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2056_l2074_action_invoke"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2075 +fn c2057_l2075_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2057_l2075_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2076 +fn c2058_l2076_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2058_l2076_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2077 +fn c2059_l2077_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2059_l2077_action_invoke"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2078 +fn c2060_l2078_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2060_l2078_action_invoke"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2079 +fn c2061_l2079_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2061_l2079_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2080 +fn c2062_l2080_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2062_l2080_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2081 +fn c2063_l2081_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2063_l2081_action_invoke"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2082 +fn c2064_l2082_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2064_l2082_action_invoke"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2083 +fn c2065_l2083_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2065_l2083_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2084 +fn c2066_l2084_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2066_l2084_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2085 +fn c2067_l2085_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2067_l2085_action_invoke"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2086 +fn c2068_l2086_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2068_l2086_action_invoke"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2087 +fn c2069_l2087_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2069_l2087_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2088 +fn c2070_l2088_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2070_l2088_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2089 +fn c2071_l2089_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2071_l2089_action_invoke"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2090 +fn c2072_l2090_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2072_l2090_action_invoke"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2091 +fn c2073_l2091_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2073_l2091_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c2073_l2091_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2092 +fn c2074_l2092_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2074_l2092_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c2074_l2092_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2093 +fn c2075_l2093_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2075_l2093_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c2075_l2093_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2094 +fn c2076_l2094_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2076_l2094_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c2076_l2094_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2095 +fn c2077_l2095_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2077_l2095_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c2077_l2095_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2096 +fn c2078_l2096_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2078_l2096_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c2078_l2096_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2097 +fn c2079_l2097_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2079_l2097_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c2079_l2097_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2098 +fn c2080_l2098_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2080_l2098_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c2080_l2098_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2099 +fn c2081_l2099_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2081_l2099_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2100 +fn c2082_l2100_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2082_l2100_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2101 +fn c2083_l2101_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2083_l2101_action_invoke"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2102 +fn c2084_l2102_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2084_l2102_action_invoke"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2103 +fn c2085_l2103_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2085_l2103_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2104 +fn c2086_l2104_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2086_l2104_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2105 +fn c2087_l2105_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2087_l2105_action_invoke"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2106 +fn c2088_l2106_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2088_l2106_action_invoke"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2107 +fn c2089_l2107_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2089_l2107_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2108 +fn c2090_l2108_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2090_l2108_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2109 +fn c2091_l2109_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2091_l2109_action_invoke"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2110 +fn c2092_l2110_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2092_l2110_action_invoke"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2111 +fn c2093_l2111_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2093_l2111_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2112 +fn c2094_l2112_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2094_l2112_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2113 +fn c2095_l2113_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2095_l2113_action_invoke"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2114 +fn c2096_l2114_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2096_l2114_action_invoke"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2115 +fn c2097_l2115_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2097_l2115_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2116 +fn c2098_l2116_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2098_l2116_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2117 +fn c2099_l2117_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2099_l2117_action_invoke"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2118 +fn c2100_l2118_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2100_l2118_action_invoke"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2119 +fn c2101_l2119_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2101_l2119_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2120 +fn c2102_l2120_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2102_l2120_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2121 +fn c2103_l2121_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2103_l2121_action_invoke"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2122 +fn c2104_l2122_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2104_l2122_action_invoke"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2123 +fn c2105_l2123_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2105_l2123_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2124 +fn c2106_l2124_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2106_l2124_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2125 +fn c2107_l2125_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2107_l2125_action_invoke"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2126 +fn c2108_l2126_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2108_l2126_action_invoke"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2127 +fn c2109_l2127_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2109_l2127_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2128 +fn c2110_l2128_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2110_l2128_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2129 +fn c2111_l2129_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2111_l2129_action_invoke"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2130 +fn c2112_l2130_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2112_l2130_action_invoke"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2131 +fn c2113_l2131_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2113_l2131_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c2113_l2131_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2132 +fn c2114_l2132_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2114_l2132_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c2114_l2132_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2133 +fn c2115_l2133_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2115_l2133_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c2115_l2133_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2134 +fn c2116_l2134_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2116_l2134_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c2116_l2134_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2135 +fn c2117_l2135_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2117_l2135_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c2117_l2135_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2136 +fn c2118_l2136_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2118_l2136_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c2118_l2136_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2137 +fn c2119_l2137_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2119_l2137_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c2119_l2137_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2138 +fn c2120_l2138_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2120_l2138_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c2120_l2138_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2139 +fn c2121_l2139_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2121_l2139_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2140 +fn c2122_l2140_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2122_l2140_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2141 +fn c2123_l2141_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2123_l2141_action_invoke"); + let result = instance.call("max", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2142 +fn c2124_l2142_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2124_l2142_action_invoke"); + let result = instance.call("max", &[Value::F64((0.5f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2143 +fn c2125_l2143_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2125_l2143_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2144 +fn c2126_l2144_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2126_l2144_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2145 +fn c2127_l2145_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2127_l2145_action_invoke"); + let result = instance.call("max", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2146 +fn c2128_l2146_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2128_l2146_action_invoke"); + let result = instance.call("max", &[Value::F64((0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2147 +fn c2129_l2147_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2129_l2147_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2148 +fn c2130_l2148_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2130_l2148_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2149 +fn c2131_l2149_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2131_l2149_action_invoke"); + let result = instance.call("max", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2150 +fn c2132_l2150_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2132_l2150_action_invoke"); + let result = instance.call("max", &[Value::F64((0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2151 +fn c2133_l2151_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2133_l2151_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2152 +fn c2134_l2152_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2134_l2152_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2153 +fn c2135_l2153_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2135_l2153_action_invoke"); + let result = instance.call("max", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2154 +fn c2136_l2154_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2136_l2154_action_invoke"); + let result = instance.call("max", &[Value::F64((0.5f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2155 +fn c2137_l2155_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2137_l2155_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.5f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2156 +fn c2138_l2156_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2138_l2156_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.5f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2157 +fn c2139_l2157_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2139_l2157_action_invoke"); + let result = instance.call("max", &[Value::F64((0.5f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2158 +fn c2140_l2158_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2140_l2158_action_invoke"); + let result = instance.call("max", &[Value::F64((0.5f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2159 +fn c2141_l2159_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2141_l2159_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.5f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2160 +fn c2142_l2160_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2142_l2160_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.5f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2161 +fn c2143_l2161_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2143_l2161_action_invoke"); + let result = instance.call("max", &[Value::F64((0.5f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2162 +fn c2144_l2162_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2144_l2162_action_invoke"); + let result = instance.call("max", &[Value::F64((0.5f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2163 +fn c2145_l2163_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2145_l2163_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.5f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2164 +fn c2146_l2164_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2146_l2164_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.5f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2165 +fn c2147_l2165_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2147_l2165_action_invoke"); + let result = instance.call("max", &[Value::F64((0.5f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2166 +fn c2148_l2166_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2148_l2166_action_invoke"); + let result = instance.call("max", &[Value::F64((0.5f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2167 +fn c2149_l2167_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2149_l2167_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2168 +fn c2150_l2168_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2150_l2168_action_invoke"); + let result = instance.call("max", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2169 +fn c2151_l2169_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2151_l2169_action_invoke"); + let result = instance.call("max", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2170 +fn c2152_l2170_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2152_l2170_action_invoke"); + let result = instance.call("max", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2171 +fn c2153_l2171_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2153_l2171_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c2153_l2171_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2172 +fn c2154_l2172_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2154_l2172_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c2154_l2172_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2173 +fn c2155_l2173_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2155_l2173_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c2155_l2173_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2174 +fn c2156_l2174_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2156_l2174_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c2156_l2174_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2175 +fn c2157_l2175_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2157_l2175_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c2157_l2175_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2176 +fn c2158_l2176_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2158_l2176_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c2158_l2176_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2177 +fn c2159_l2177_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2159_l2177_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c2159_l2177_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2178 +fn c2160_l2178_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2160_l2178_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c2160_l2178_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2179 +fn c2161_l2179_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2161_l2179_action_invoke"); + let result = instance.call("max", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2180 +fn c2162_l2180_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2162_l2180_action_invoke"); + let result = instance.call("max", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2181 +fn c2163_l2181_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2163_l2181_action_invoke"); + let result = instance.call("max", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2182 +fn c2164_l2182_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2164_l2182_action_invoke"); + let result = instance.call("max", &[Value::F64((1.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2183 +fn c2165_l2183_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2165_l2183_action_invoke"); + let result = instance.call("max", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2184 +fn c2166_l2184_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2166_l2184_action_invoke"); + let result = instance.call("max", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2185 +fn c2167_l2185_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2167_l2185_action_invoke"); + let result = instance.call("max", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2186 +fn c2168_l2186_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2168_l2186_action_invoke"); + let result = instance.call("max", &[Value::F64((1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2187 +fn c2169_l2187_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2169_l2187_action_invoke"); + let result = instance.call("max", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2188 +fn c2170_l2188_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2170_l2188_action_invoke"); + let result = instance.call("max", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2189 +fn c2171_l2189_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2171_l2189_action_invoke"); + let result = instance.call("max", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2190 +fn c2172_l2190_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2172_l2190_action_invoke"); + let result = instance.call("max", &[Value::F64((1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2191 +fn c2173_l2191_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2173_l2191_action_invoke"); + let result = instance.call("max", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2192 +fn c2174_l2192_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2174_l2192_action_invoke"); + let result = instance.call("max", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2193 +fn c2175_l2193_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2175_l2193_action_invoke"); + let result = instance.call("max", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2194 +fn c2176_l2194_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2176_l2194_action_invoke"); + let result = instance.call("max", &[Value::F64((1.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2195 +fn c2177_l2195_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2177_l2195_action_invoke"); + let result = instance.call("max", &[Value::F64((-1.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2196 +fn c2178_l2196_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2178_l2196_action_invoke"); + let result = instance.call("max", &[Value::F64((-1.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2197 +fn c2179_l2197_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2179_l2197_action_invoke"); + let result = instance.call("max", &[Value::F64((1.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2198 +fn c2180_l2198_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2180_l2198_action_invoke"); + let result = instance.call("max", &[Value::F64((1.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2199 +fn c2181_l2199_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2181_l2199_action_invoke"); + let result = instance.call("max", &[Value::F64((-1.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2200 +fn c2182_l2200_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2182_l2200_action_invoke"); + let result = instance.call("max", &[Value::F64((-1.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2201 +fn c2183_l2201_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2183_l2201_action_invoke"); + let result = instance.call("max", &[Value::F64((1.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2202 +fn c2184_l2202_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2184_l2202_action_invoke"); + let result = instance.call("max", &[Value::F64((1.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2203 +fn c2185_l2203_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2185_l2203_action_invoke"); + let result = instance.call("max", &[Value::F64((-1.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2204 +fn c2186_l2204_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2186_l2204_action_invoke"); + let result = instance.call("max", &[Value::F64((-1.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2205 +fn c2187_l2205_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2187_l2205_action_invoke"); + let result = instance.call("max", &[Value::F64((1.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2206 +fn c2188_l2206_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2188_l2206_action_invoke"); + let result = instance.call("max", &[Value::F64((1.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2207 +fn c2189_l2207_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2189_l2207_action_invoke"); + let result = instance.call("max", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2208 +fn c2190_l2208_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2190_l2208_action_invoke"); + let result = instance.call("max", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2209 +fn c2191_l2209_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2191_l2209_action_invoke"); + let result = instance.call("max", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2210 +fn c2192_l2210_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2192_l2210_action_invoke"); + let result = instance.call("max", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2211 +fn c2193_l2211_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2193_l2211_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c2193_l2211_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2212 +fn c2194_l2212_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2194_l2212_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c2194_l2212_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2213 +fn c2195_l2213_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2195_l2213_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c2195_l2213_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2214 +fn c2196_l2214_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2196_l2214_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c2196_l2214_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2215 +fn c2197_l2215_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2197_l2215_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c2197_l2215_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2216 +fn c2198_l2216_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2198_l2216_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c2198_l2216_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2217 +fn c2199_l2217_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2199_l2217_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c2199_l2217_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2218 +fn c2200_l2218_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2200_l2218_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c2200_l2218_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2219 +fn c2201_l2219_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2201_l2219_action_invoke"); + let result = instance.call("max", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2220 +fn c2202_l2220_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2202_l2220_action_invoke"); + let result = instance.call("max", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2221 +fn c2203_l2221_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2203_l2221_action_invoke"); + let result = instance.call("max", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2222 +fn c2204_l2222_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2204_l2222_action_invoke"); + let result = instance.call("max", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2223 +fn c2205_l2223_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2205_l2223_action_invoke"); + let result = instance.call("max", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2224 +fn c2206_l2224_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2206_l2224_action_invoke"); + let result = instance.call("max", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2225 +fn c2207_l2225_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2207_l2225_action_invoke"); + let result = instance.call("max", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2226 +fn c2208_l2226_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2208_l2226_action_invoke"); + let result = instance.call("max", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2227 +fn c2209_l2227_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2209_l2227_action_invoke"); + let result = instance.call("max", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2228 +fn c2210_l2228_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2210_l2228_action_invoke"); + let result = instance.call("max", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2229 +fn c2211_l2229_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2211_l2229_action_invoke"); + let result = instance.call("max", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2230 +fn c2212_l2230_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2212_l2230_action_invoke"); + let result = instance.call("max", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2231 +fn c2213_l2231_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2213_l2231_action_invoke"); + let result = instance.call("max", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2232 +fn c2214_l2232_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2214_l2232_action_invoke"); + let result = instance.call("max", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2233 +fn c2215_l2233_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2215_l2233_action_invoke"); + let result = instance.call("max", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2234 +fn c2216_l2234_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2216_l2234_action_invoke"); + let result = instance.call("max", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2235 +fn c2217_l2235_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2217_l2235_action_invoke"); + let result = instance.call("max", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2236 +fn c2218_l2236_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2218_l2236_action_invoke"); + let result = instance.call("max", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2237 +fn c2219_l2237_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2219_l2237_action_invoke"); + let result = instance.call("max", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2238 +fn c2220_l2238_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2220_l2238_action_invoke"); + let result = instance.call("max", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2239 +fn c2221_l2239_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2221_l2239_action_invoke"); + let result = instance.call("max", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2240 +fn c2222_l2240_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2222_l2240_action_invoke"); + let result = instance.call("max", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2241 +fn c2223_l2241_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2223_l2241_action_invoke"); + let result = instance.call("max", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2242 +fn c2224_l2242_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2224_l2242_action_invoke"); + let result = instance.call("max", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2243 +fn c2225_l2243_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2225_l2243_action_invoke"); + let result = instance.call("max", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2244 +fn c2226_l2244_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2226_l2244_action_invoke"); + let result = instance.call("max", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2245 +fn c2227_l2245_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2227_l2245_action_invoke"); + let result = instance.call("max", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2246 +fn c2228_l2246_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2228_l2246_action_invoke"); + let result = instance.call("max", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2247 +fn c2229_l2247_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2229_l2247_action_invoke"); + let result = instance.call("max", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2248 +fn c2230_l2248_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2230_l2248_action_invoke"); + let result = instance.call("max", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2249 +fn c2231_l2249_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2231_l2249_action_invoke"); + let result = instance.call("max", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2250 +fn c2232_l2250_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2232_l2250_action_invoke"); + let result = instance.call("max", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2251 +fn c2233_l2251_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2233_l2251_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c2233_l2251_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2252 +fn c2234_l2252_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2234_l2252_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c2234_l2252_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2253 +fn c2235_l2253_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2235_l2253_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c2235_l2253_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2254 +fn c2236_l2254_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2236_l2254_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c2236_l2254_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2255 +fn c2237_l2255_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2237_l2255_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c2237_l2255_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2256 +fn c2238_l2256_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2238_l2256_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c2238_l2256_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2257 +fn c2239_l2257_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2239_l2257_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c2239_l2257_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2258 +fn c2240_l2258_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2240_l2258_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c2240_l2258_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2259 +fn c2241_l2259_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2241_l2259_action_invoke"); + let result = instance.call("max", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2260 +fn c2242_l2260_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2242_l2260_action_invoke"); + let result = instance.call("max", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2261 +fn c2243_l2261_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2243_l2261_action_invoke"); + let result = instance.call("max", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2262 +fn c2244_l2262_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2244_l2262_action_invoke"); + let result = instance.call("max", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2263 +fn c2245_l2263_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2245_l2263_action_invoke"); + let result = instance.call("max", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2264 +fn c2246_l2264_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2246_l2264_action_invoke"); + let result = instance.call("max", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2265 +fn c2247_l2265_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2247_l2265_action_invoke"); + let result = instance.call("max", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2266 +fn c2248_l2266_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2248_l2266_action_invoke"); + let result = instance.call("max", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2267 +fn c2249_l2267_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2249_l2267_action_invoke"); + let result = instance.call("max", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2268 +fn c2250_l2268_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2250_l2268_action_invoke"); + let result = instance.call("max", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2269 +fn c2251_l2269_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2251_l2269_action_invoke"); + let result = instance.call("max", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2270 +fn c2252_l2270_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2252_l2270_action_invoke"); + let result = instance.call("max", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2271 +fn c2253_l2271_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2253_l2271_action_invoke"); + let result = instance.call("max", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2272 +fn c2254_l2272_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2254_l2272_action_invoke"); + let result = instance.call("max", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2273 +fn c2255_l2273_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2255_l2273_action_invoke"); + let result = instance.call("max", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2274 +fn c2256_l2274_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2256_l2274_action_invoke"); + let result = instance.call("max", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2275 +fn c2257_l2275_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2257_l2275_action_invoke"); + let result = instance.call("max", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2276 +fn c2258_l2276_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2258_l2276_action_invoke"); + let result = instance.call("max", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2277 +fn c2259_l2277_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2259_l2277_action_invoke"); + let result = instance.call("max", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2278 +fn c2260_l2278_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2260_l2278_action_invoke"); + let result = instance.call("max", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2279 +fn c2261_l2279_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2261_l2279_action_invoke"); + let result = instance.call("max", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2280 +fn c2262_l2280_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2262_l2280_action_invoke"); + let result = instance.call("max", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2281 +fn c2263_l2281_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2263_l2281_action_invoke"); + let result = instance.call("max", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2282 +fn c2264_l2282_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2264_l2282_action_invoke"); + let result = instance.call("max", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2283 +fn c2265_l2283_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2265_l2283_action_invoke"); + let result = instance.call("max", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2284 +fn c2266_l2284_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2266_l2284_action_invoke"); + let result = instance.call("max", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2285 +fn c2267_l2285_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2267_l2285_action_invoke"); + let result = instance.call("max", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2286 +fn c2268_l2286_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2268_l2286_action_invoke"); + let result = instance.call("max", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2287 +fn c2269_l2287_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2269_l2287_action_invoke"); + let result = instance.call("max", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2288 +fn c2270_l2288_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2270_l2288_action_invoke"); + let result = instance.call("max", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2289 +fn c2271_l2289_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2271_l2289_action_invoke"); + let result = instance.call("max", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2290 +fn c2272_l2290_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2272_l2290_action_invoke"); + let result = instance.call("max", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2291 +fn c2273_l2291_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2273_l2291_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c2273_l2291_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2292 +fn c2274_l2292_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2274_l2292_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c2274_l2292_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2293 +fn c2275_l2293_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2275_l2293_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c2275_l2293_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2294 +fn c2276_l2294_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2276_l2294_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c2276_l2294_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2295 +fn c2277_l2295_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2277_l2295_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c2277_l2295_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2296 +fn c2278_l2296_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2278_l2296_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c2278_l2296_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2297 +fn c2279_l2297_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2279_l2297_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c2279_l2297_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2298 +fn c2280_l2298_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2280_l2298_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c2280_l2298_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2299 +fn c2281_l2299_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2281_l2299_action_invoke"); + let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2300 +fn c2282_l2300_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2282_l2300_action_invoke"); + let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2301 +fn c2283_l2301_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2283_l2301_action_invoke"); + let result = instance.call("max", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2302 +fn c2284_l2302_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2284_l2302_action_invoke"); + let result = instance.call("max", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2303 +fn c2285_l2303_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2285_l2303_action_invoke"); + let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2304 +fn c2286_l2304_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2286_l2304_action_invoke"); + let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2305 +fn c2287_l2305_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2287_l2305_action_invoke"); + let result = instance.call("max", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2306 +fn c2288_l2306_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2288_l2306_action_invoke"); + let result = instance.call("max", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2307 +fn c2289_l2307_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2289_l2307_action_invoke"); + let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2308 +fn c2290_l2308_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2290_l2308_action_invoke"); + let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2309 +fn c2291_l2309_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2291_l2309_action_invoke"); + let result = instance.call("max", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2310 +fn c2292_l2310_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2292_l2310_action_invoke"); + let result = instance.call("max", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2311 +fn c2293_l2311_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2293_l2311_action_invoke"); + let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2312 +fn c2294_l2312_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2294_l2312_action_invoke"); + let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2313 +fn c2295_l2313_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2295_l2313_action_invoke"); + let result = instance.call("max", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2314 +fn c2296_l2314_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2296_l2314_action_invoke"); + let result = instance.call("max", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2315 +fn c2297_l2315_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2297_l2315_action_invoke"); + let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2316 +fn c2298_l2316_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2298_l2316_action_invoke"); + let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2317 +fn c2299_l2317_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2299_l2317_action_invoke"); + let result = instance.call("max", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2318 +fn c2300_l2318_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2300_l2318_action_invoke"); + let result = instance.call("max", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2319 +fn c2301_l2319_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2301_l2319_action_invoke"); + let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2320 +fn c2302_l2320_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2302_l2320_action_invoke"); + let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2321 +fn c2303_l2321_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2303_l2321_action_invoke"); + let result = instance.call("max", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2322 +fn c2304_l2322_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2304_l2322_action_invoke"); + let result = instance.call("max", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2323 +fn c2305_l2323_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2305_l2323_action_invoke"); + let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2324 +fn c2306_l2324_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2306_l2324_action_invoke"); + let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2325 +fn c2307_l2325_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2307_l2325_action_invoke"); + let result = instance.call("max", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2326 +fn c2308_l2326_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2308_l2326_action_invoke"); + let result = instance.call("max", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2327 +fn c2309_l2327_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2309_l2327_action_invoke"); + let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2328 +fn c2310_l2328_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2310_l2328_action_invoke"); + let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2329 +fn c2311_l2329_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2311_l2329_action_invoke"); + let result = instance.call("max", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2330 +fn c2312_l2330_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2312_l2330_action_invoke"); + let result = instance.call("max", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2331 +fn c2313_l2331_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2313_l2331_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c2313_l2331_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2332 +fn c2314_l2332_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2314_l2332_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c2314_l2332_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2333 +fn c2315_l2333_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2315_l2333_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c2315_l2333_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2334 +fn c2316_l2334_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2316_l2334_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c2316_l2334_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2335 +fn c2317_l2335_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2317_l2335_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c2317_l2335_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2336 +fn c2318_l2336_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2318_l2336_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c2318_l2336_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2337 +fn c2319_l2337_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2319_l2337_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c2319_l2337_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2338 +fn c2320_l2338_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2320_l2338_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c2320_l2338_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2339 +fn c2321_l2339_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2321_l2339_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.0f64).to_bits())]).unwrap().expect("Missing result in c2321_l2339_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2340 +fn c2322_l2340_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2322_l2340_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.0f64).to_bits())]).unwrap().expect("Missing result in c2322_l2340_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2341 +fn c2323_l2341_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2323_l2341_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.0f64).to_bits())]).unwrap().expect("Missing result in c2323_l2341_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2342 +fn c2324_l2342_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2324_l2342_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.0f64).to_bits())]).unwrap().expect("Missing result in c2324_l2342_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2343 +fn c2325_l2343_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2325_l2343_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.0f64).to_bits())]).unwrap().expect("Missing result in c2325_l2343_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2344 +fn c2326_l2344_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2326_l2344_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.0f64).to_bits())]).unwrap().expect("Missing result in c2326_l2344_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2345 +fn c2327_l2345_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2327_l2345_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.0f64).to_bits())]).unwrap().expect("Missing result in c2327_l2345_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2346 +fn c2328_l2346_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2328_l2346_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.0f64).to_bits())]).unwrap().expect("Missing result in c2328_l2346_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2347 +fn c2329_l2347_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2329_l2347_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c2329_l2347_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2348 +fn c2330_l2348_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2330_l2348_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c2330_l2348_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2349 +fn c2331_l2349_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2331_l2349_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c2331_l2349_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2350 +fn c2332_l2350_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2332_l2350_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c2332_l2350_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2351 +fn c2333_l2351_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2333_l2351_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c2333_l2351_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2352 +fn c2334_l2352_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2334_l2352_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c2334_l2352_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2353 +fn c2335_l2353_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2335_l2353_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c2335_l2353_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2354 +fn c2336_l2354_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2336_l2354_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c2336_l2354_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2355 +fn c2337_l2355_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2337_l2355_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c2337_l2355_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2356 +fn c2338_l2356_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2338_l2356_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c2338_l2356_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2357 +fn c2339_l2357_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2339_l2357_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c2339_l2357_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2358 +fn c2340_l2358_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2340_l2358_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c2340_l2358_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2359 +fn c2341_l2359_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2341_l2359_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c2341_l2359_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2360 +fn c2342_l2360_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2342_l2360_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c2342_l2360_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2361 +fn c2343_l2361_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2343_l2361_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c2343_l2361_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2362 +fn c2344_l2362_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2344_l2362_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c2344_l2362_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2363 +fn c2345_l2363_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2345_l2363_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.5f64).to_bits())]).unwrap().expect("Missing result in c2345_l2363_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2364 +fn c2346_l2364_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2346_l2364_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.5f64).to_bits())]).unwrap().expect("Missing result in c2346_l2364_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2365 +fn c2347_l2365_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2347_l2365_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.5f64).to_bits())]).unwrap().expect("Missing result in c2347_l2365_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2366 +fn c2348_l2366_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2348_l2366_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.5f64).to_bits())]).unwrap().expect("Missing result in c2348_l2366_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2367 +fn c2349_l2367_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2349_l2367_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.5f64).to_bits())]).unwrap().expect("Missing result in c2349_l2367_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2368 +fn c2350_l2368_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2350_l2368_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.5f64).to_bits())]).unwrap().expect("Missing result in c2350_l2368_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2369 +fn c2351_l2369_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2351_l2369_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.5f64).to_bits())]).unwrap().expect("Missing result in c2351_l2369_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2370 +fn c2352_l2370_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2352_l2370_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.5f64).to_bits())]).unwrap().expect("Missing result in c2352_l2370_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2371 +fn c2353_l2371_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2353_l2371_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-1.0f64).to_bits())]).unwrap().expect("Missing result in c2353_l2371_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2372 +fn c2354_l2372_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2354_l2372_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-1.0f64).to_bits())]).unwrap().expect("Missing result in c2354_l2372_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2373 +fn c2355_l2373_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2355_l2373_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((1.0f64).to_bits())]).unwrap().expect("Missing result in c2355_l2373_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2374 +fn c2356_l2374_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2356_l2374_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((1.0f64).to_bits())]).unwrap().expect("Missing result in c2356_l2374_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2375 +fn c2357_l2375_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2357_l2375_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-1.0f64).to_bits())]).unwrap().expect("Missing result in c2357_l2375_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2376 +fn c2358_l2376_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2358_l2376_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-1.0f64).to_bits())]).unwrap().expect("Missing result in c2358_l2376_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2377 +fn c2359_l2377_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2359_l2377_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((1.0f64).to_bits())]).unwrap().expect("Missing result in c2359_l2377_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2378 +fn c2360_l2378_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2360_l2378_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((1.0f64).to_bits())]).unwrap().expect("Missing result in c2360_l2378_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2379 +fn c2361_l2379_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2361_l2379_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c2361_l2379_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2380 +fn c2362_l2380_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2362_l2380_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c2362_l2380_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2381 +fn c2363_l2381_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2363_l2381_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c2363_l2381_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2382 +fn c2364_l2382_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2364_l2382_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c2364_l2382_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2383 +fn c2365_l2383_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2365_l2383_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c2365_l2383_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2384 +fn c2366_l2384_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2366_l2384_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c2366_l2384_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2385 +fn c2367_l2385_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2367_l2385_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c2367_l2385_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2386 +fn c2368_l2386_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2368_l2386_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c2368_l2386_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2387 +fn c2369_l2387_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2369_l2387_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c2369_l2387_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2388 +fn c2370_l2388_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2370_l2388_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c2370_l2388_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2389 +fn c2371_l2389_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2371_l2389_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c2371_l2389_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2390 +fn c2372_l2390_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2372_l2390_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c2372_l2390_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2391 +fn c2373_l2391_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2373_l2391_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c2373_l2391_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2392 +fn c2374_l2392_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2374_l2392_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c2374_l2392_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2393 +fn c2375_l2393_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2375_l2393_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c2375_l2393_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2394 +fn c2376_l2394_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2376_l2394_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c2376_l2394_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2395 +fn c2377_l2395_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2377_l2395_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c2377_l2395_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2396 +fn c2378_l2396_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2378_l2396_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c2378_l2396_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2397 +fn c2379_l2397_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2379_l2397_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::INFINITY.to_bits())]).unwrap().expect("Missing result in c2379_l2397_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2398 +fn c2380_l2398_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2380_l2398_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::INFINITY.to_bits())]).unwrap().expect("Missing result in c2380_l2398_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2399 +fn c2381_l2399_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2381_l2399_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c2381_l2399_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2400 +fn c2382_l2400_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2382_l2400_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c2382_l2400_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2401 +fn c2383_l2401_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2383_l2401_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::INFINITY.to_bits())]).unwrap().expect("Missing result in c2383_l2401_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2402 +fn c2384_l2402_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2384_l2402_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::INFINITY.to_bits())]).unwrap().expect("Missing result in c2384_l2402_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2403 +fn c2385_l2403_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2385_l2403_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c2385_l2403_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2404 +fn c2386_l2404_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2386_l2404_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c2386_l2404_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2405 +fn c2387_l2405_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2387_l2405_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c2387_l2405_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2406 +fn c2388_l2406_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2388_l2406_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c2388_l2406_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2407 +fn c2389_l2407_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2389_l2407_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c2389_l2407_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2408 +fn c2390_l2408_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2390_l2408_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c2390_l2408_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2409 +fn c2391_l2409_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2391_l2409_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c2391_l2409_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2410 +fn c2392_l2410_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2392_l2410_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c2392_l2410_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2411 +fn c2393_l2411_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2393_l2411_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c2393_l2411_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2412 +fn c2394_l2412_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2394_l2412_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c2394_l2412_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2413 +fn c2395_l2413_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2395_l2413_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c2395_l2413_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2414 +fn c2396_l2414_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2396_l2414_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c2396_l2414_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2415 +fn c2397_l2415_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2397_l2415_assert_return_canonical_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c2397_l2415_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2416 +fn c2398_l2416_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2398_l2416_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c2398_l2416_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2417 +fn c2399_l2417_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2399_l2417_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c2399_l2417_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2418 +fn c2400_l2418_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2400_l2418_assert_return_arithmetic_nan"); + let result = instance.call("max", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c2400_l2418_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2419 +fn c2401_l2419_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2401_l2419_action_invoke"); + let result = instance.call("sqrt", &[Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2420 +fn c2402_l2420_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2402_l2420_action_invoke"); + let result = instance.call("sqrt", &[Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2421 +fn c2403_l2421_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2403_l2421_assert_return_canonical_nan"); + let result = instance.call("sqrt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]).unwrap().expect("Missing result in c2403_l2421_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2422 +fn c2404_l2422_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2404_l2422_action_invoke"); + let result = instance.call("sqrt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022227587494850775f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2423 +fn c2405_l2423_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2405_l2423_assert_return_canonical_nan"); + let result = instance.call("sqrt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]).unwrap().expect("Missing result in c2405_l2423_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2424 +fn c2406_l2424_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2406_l2424_action_invoke"); + let result = instance.call("sqrt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014916681462400413f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2425 +fn c2407_l2425_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2407_l2425_assert_return_canonical_nan"); + let result = instance.call("sqrt", &[Value::F64((-0.5f64).to_bits())]).unwrap().expect("Missing result in c2407_l2425_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2426 +fn c2408_l2426_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2408_l2426_action_invoke"); + let result = instance.call("sqrt", &[Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.7071067811865476f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2427 +fn c2409_l2427_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2409_l2427_assert_return_canonical_nan"); + let result = instance.call("sqrt", &[Value::F64((-1.0f64).to_bits())]).unwrap().expect("Missing result in c2409_l2427_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2428 +fn c2410_l2428_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2410_l2428_action_invoke"); + let result = instance.call("sqrt", &[Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2429 +fn c2411_l2429_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2411_l2429_assert_return_canonical_nan"); + let result = instance.call("sqrt", &[Value::F64((-6.283185307179586f64).to_bits())]).unwrap().expect("Missing result in c2411_l2429_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2430 +fn c2412_l2430_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2412_l2430_action_invoke"); + let result = instance.call("sqrt", &[Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((2.5066282746310002f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2431 +fn c2413_l2431_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2413_l2431_assert_return_canonical_nan"); + let result = instance.call("sqrt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]).unwrap().expect("Missing result in c2413_l2431_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2432 +fn c2414_l2432_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2414_l2432_action_invoke"); + let result = instance.call("sqrt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((13407807929942596000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2433 +fn c2415_l2433_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2415_l2433_assert_return_canonical_nan"); + let result = instance.call("sqrt", &[Value::F64(f64::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c2415_l2433_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2434 +fn c2416_l2434_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2416_l2434_action_invoke"); + let result = instance.call("sqrt", &[Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2435 +fn c2417_l2435_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2417_l2435_assert_return_canonical_nan"); + let result = instance.call("sqrt", &[Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c2417_l2435_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2436 +fn c2418_l2436_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2418_l2436_assert_return_arithmetic_nan"); + let result = instance.call("sqrt", &[Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c2418_l2436_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2437 +fn c2419_l2437_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2419_l2437_assert_return_canonical_nan"); + let result = instance.call("sqrt", &[Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c2419_l2437_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2438 +fn c2420_l2438_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2420_l2438_assert_return_arithmetic_nan"); + let result = instance.call("sqrt", &[Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c2420_l2438_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2439 +fn c2421_l2439_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2421_l2439_action_invoke"); + let result = instance.call("floor", &[Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2440 +fn c2422_l2440_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2422_l2440_action_invoke"); + let result = instance.call("floor", &[Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2441 +fn c2423_l2441_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2423_l2441_action_invoke"); + let result = instance.call("floor", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2442 +fn c2424_l2442_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2424_l2442_action_invoke"); + let result = instance.call("floor", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2443 +fn c2425_l2443_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2425_l2443_action_invoke"); + let result = instance.call("floor", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2444 +fn c2426_l2444_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2426_l2444_action_invoke"); + let result = instance.call("floor", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2445 +fn c2427_l2445_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2427_l2445_action_invoke"); + let result = instance.call("floor", &[Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2446 +fn c2428_l2446_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2428_l2446_action_invoke"); + let result = instance.call("floor", &[Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2447 +fn c2429_l2447_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2429_l2447_action_invoke"); + let result = instance.call("floor", &[Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2448 +fn c2430_l2448_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2430_l2448_action_invoke"); + let result = instance.call("floor", &[Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2449 +fn c2431_l2449_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2431_l2449_action_invoke"); + let result = instance.call("floor", &[Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-7.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2450 +fn c2432_l2450_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2432_l2450_action_invoke"); + let result = instance.call("floor", &[Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2451 +fn c2433_l2451_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2433_l2451_action_invoke"); + let result = instance.call("floor", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2452 +fn c2434_l2452_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2434_l2452_action_invoke"); + let result = instance.call("floor", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2453 +fn c2435_l2453_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2435_l2453_action_invoke"); + let result = instance.call("floor", &[Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2454 +fn c2436_l2454_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2436_l2454_action_invoke"); + let result = instance.call("floor", &[Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2455 +fn c2437_l2455_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2437_l2455_assert_return_canonical_nan"); + let result = instance.call("floor", &[Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c2437_l2455_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2456 +fn c2438_l2456_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2438_l2456_assert_return_arithmetic_nan"); + let result = instance.call("floor", &[Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c2438_l2456_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2457 +fn c2439_l2457_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2439_l2457_assert_return_canonical_nan"); + let result = instance.call("floor", &[Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c2439_l2457_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2458 +fn c2440_l2458_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2440_l2458_assert_return_arithmetic_nan"); + let result = instance.call("floor", &[Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c2440_l2458_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2459 +fn c2441_l2459_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2441_l2459_action_invoke"); + let result = instance.call("ceil", &[Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2460 +fn c2442_l2460_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2442_l2460_action_invoke"); + let result = instance.call("ceil", &[Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2461 +fn c2443_l2461_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2443_l2461_action_invoke"); + let result = instance.call("ceil", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2462 +fn c2444_l2462_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2444_l2462_action_invoke"); + let result = instance.call("ceil", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2463 +fn c2445_l2463_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2445_l2463_action_invoke"); + let result = instance.call("ceil", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2464 +fn c2446_l2464_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2446_l2464_action_invoke"); + let result = instance.call("ceil", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2465 +fn c2447_l2465_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2447_l2465_action_invoke"); + let result = instance.call("ceil", &[Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2466 +fn c2448_l2466_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2448_l2466_action_invoke"); + let result = instance.call("ceil", &[Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2467 +fn c2449_l2467_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2449_l2467_action_invoke"); + let result = instance.call("ceil", &[Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2468 +fn c2450_l2468_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2450_l2468_action_invoke"); + let result = instance.call("ceil", &[Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2469 +fn c2451_l2469_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2451_l2469_action_invoke"); + let result = instance.call("ceil", &[Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2470 +fn c2452_l2470_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2452_l2470_action_invoke"); + let result = instance.call("ceil", &[Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((7.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2471 +fn c2453_l2471_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2453_l2471_action_invoke"); + let result = instance.call("ceil", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2472 +fn c2454_l2472_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2454_l2472_action_invoke"); + let result = instance.call("ceil", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2473 +fn c2455_l2473_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2455_l2473_action_invoke"); + let result = instance.call("ceil", &[Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2474 +fn c2456_l2474_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2456_l2474_action_invoke"); + let result = instance.call("ceil", &[Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2475 +fn c2457_l2475_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2457_l2475_assert_return_canonical_nan"); + let result = instance.call("ceil", &[Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c2457_l2475_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2476 +fn c2458_l2476_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2458_l2476_assert_return_arithmetic_nan"); + let result = instance.call("ceil", &[Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c2458_l2476_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2477 +fn c2459_l2477_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2459_l2477_assert_return_canonical_nan"); + let result = instance.call("ceil", &[Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c2459_l2477_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2478 +fn c2460_l2478_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2460_l2478_assert_return_arithmetic_nan"); + let result = instance.call("ceil", &[Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c2460_l2478_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2479 +fn c2461_l2479_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2461_l2479_action_invoke"); + let result = instance.call("trunc", &[Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2480 +fn c2462_l2480_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2462_l2480_action_invoke"); + let result = instance.call("trunc", &[Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2481 +fn c2463_l2481_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2463_l2481_action_invoke"); + let result = instance.call("trunc", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2482 +fn c2464_l2482_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2464_l2482_action_invoke"); + let result = instance.call("trunc", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2483 +fn c2465_l2483_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2465_l2483_action_invoke"); + let result = instance.call("trunc", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2484 +fn c2466_l2484_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2466_l2484_action_invoke"); + let result = instance.call("trunc", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2485 +fn c2467_l2485_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2467_l2485_action_invoke"); + let result = instance.call("trunc", &[Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2486 +fn c2468_l2486_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2468_l2486_action_invoke"); + let result = instance.call("trunc", &[Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2487 +fn c2469_l2487_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2469_l2487_action_invoke"); + let result = instance.call("trunc", &[Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2488 +fn c2470_l2488_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2470_l2488_action_invoke"); + let result = instance.call("trunc", &[Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2489 +fn c2471_l2489_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2471_l2489_action_invoke"); + let result = instance.call("trunc", &[Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2490 +fn c2472_l2490_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2472_l2490_action_invoke"); + let result = instance.call("trunc", &[Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2491 +fn c2473_l2491_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2473_l2491_action_invoke"); + let result = instance.call("trunc", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2492 +fn c2474_l2492_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2474_l2492_action_invoke"); + let result = instance.call("trunc", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2493 +fn c2475_l2493_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2475_l2493_action_invoke"); + let result = instance.call("trunc", &[Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2494 +fn c2476_l2494_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2476_l2494_action_invoke"); + let result = instance.call("trunc", &[Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2495 +fn c2477_l2495_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2477_l2495_assert_return_canonical_nan"); + let result = instance.call("trunc", &[Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c2477_l2495_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2496 +fn c2478_l2496_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2478_l2496_assert_return_arithmetic_nan"); + let result = instance.call("trunc", &[Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c2478_l2496_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2497 +fn c2479_l2497_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2479_l2497_assert_return_canonical_nan"); + let result = instance.call("trunc", &[Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c2479_l2497_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2498 +fn c2480_l2498_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2480_l2498_assert_return_arithmetic_nan"); + let result = instance.call("trunc", &[Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c2480_l2498_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2499 +fn c2481_l2499_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2481_l2499_action_invoke"); + let result = instance.call("nearest", &[Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2500 +fn c2482_l2500_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2482_l2500_action_invoke"); + let result = instance.call("nearest", &[Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2501 +fn c2483_l2501_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2483_l2501_action_invoke"); + let result = instance.call("nearest", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2502 +fn c2484_l2502_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2484_l2502_action_invoke"); + let result = instance.call("nearest", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2503 +fn c2485_l2503_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2485_l2503_action_invoke"); + let result = instance.call("nearest", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2504 +fn c2486_l2504_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2486_l2504_action_invoke"); + let result = instance.call("nearest", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2505 +fn c2487_l2505_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2487_l2505_action_invoke"); + let result = instance.call("nearest", &[Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2506 +fn c2488_l2506_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2488_l2506_action_invoke"); + let result = instance.call("nearest", &[Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2507 +fn c2489_l2507_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2489_l2507_action_invoke"); + let result = instance.call("nearest", &[Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2508 +fn c2490_l2508_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2490_l2508_action_invoke"); + let result = instance.call("nearest", &[Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2509 +fn c2491_l2509_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2491_l2509_action_invoke"); + let result = instance.call("nearest", &[Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2510 +fn c2492_l2510_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2492_l2510_action_invoke"); + let result = instance.call("nearest", &[Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2511 +fn c2493_l2511_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2493_l2511_action_invoke"); + let result = instance.call("nearest", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2512 +fn c2494_l2512_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2494_l2512_action_invoke"); + let result = instance.call("nearest", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2513 +fn c2495_l2513_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2495_l2513_action_invoke"); + let result = instance.call("nearest", &[Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2514 +fn c2496_l2514_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2496_l2514_action_invoke"); + let result = instance.call("nearest", &[Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 2515 +fn c2497_l2515_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2497_l2515_assert_return_canonical_nan"); + let result = instance.call("nearest", &[Value::F64(f64::from_bits(18444492273895866368) as u64)]).unwrap().expect("Missing result in c2497_l2515_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2516 +fn c2498_l2516_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2498_l2516_assert_return_arithmetic_nan"); + let result = instance.call("nearest", &[Value::F64(f64::from_bits(18443366373989023744) as u64)]).unwrap().expect("Missing result in c2498_l2516_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2517 +fn c2499_l2517_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c2499_l2517_assert_return_canonical_nan"); + let result = instance.call("nearest", &[Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c2499_l2517_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 2518 +fn c2500_l2518_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c2500_l2518_assert_return_arithmetic_nan"); + let result = instance.call("nearest", &[Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c2500_l2518_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l19_action_invoke(&mut instance); + c2_l20_action_invoke(&mut instance); + c3_l21_action_invoke(&mut instance); + c4_l22_action_invoke(&mut instance); + c5_l23_action_invoke(&mut instance); + c6_l24_action_invoke(&mut instance); + c7_l25_action_invoke(&mut instance); + c8_l26_action_invoke(&mut instance); + c9_l27_action_invoke(&mut instance); + c10_l28_action_invoke(&mut instance); + c11_l29_action_invoke(&mut instance); + c12_l30_action_invoke(&mut instance); + c13_l31_action_invoke(&mut instance); + c14_l32_action_invoke(&mut instance); + c15_l33_action_invoke(&mut instance); + c16_l34_action_invoke(&mut instance); + c17_l35_action_invoke(&mut instance); + c18_l36_action_invoke(&mut instance); + c19_l37_action_invoke(&mut instance); + c20_l38_action_invoke(&mut instance); + c21_l39_action_invoke(&mut instance); + c22_l40_action_invoke(&mut instance); + c23_l41_action_invoke(&mut instance); + c24_l42_action_invoke(&mut instance); + c25_l43_action_invoke(&mut instance); + c26_l44_action_invoke(&mut instance); + c27_l45_action_invoke(&mut instance); + c28_l46_action_invoke(&mut instance); + c29_l47_action_invoke(&mut instance); + c30_l48_action_invoke(&mut instance); + c31_l49_action_invoke(&mut instance); + c32_l50_action_invoke(&mut instance); + c33_l51_assert_return_canonical_nan(&mut instance); + c34_l52_assert_return_arithmetic_nan(&mut instance); + c35_l53_assert_return_canonical_nan(&mut instance); + c36_l54_assert_return_arithmetic_nan(&mut instance); + c37_l55_assert_return_canonical_nan(&mut instance); + c38_l56_assert_return_arithmetic_nan(&mut instance); + c39_l57_assert_return_canonical_nan(&mut instance); + c40_l58_assert_return_arithmetic_nan(&mut instance); + c41_l59_action_invoke(&mut instance); + c42_l60_action_invoke(&mut instance); + c43_l61_action_invoke(&mut instance); + c44_l62_action_invoke(&mut instance); + c45_l63_action_invoke(&mut instance); + c46_l64_action_invoke(&mut instance); + c47_l65_action_invoke(&mut instance); + c48_l66_action_invoke(&mut instance); + c49_l67_action_invoke(&mut instance); + c50_l68_action_invoke(&mut instance); + c51_l69_action_invoke(&mut instance); + c52_l70_action_invoke(&mut instance); + c53_l71_action_invoke(&mut instance); + c54_l72_action_invoke(&mut instance); + c55_l73_action_invoke(&mut instance); + c56_l74_action_invoke(&mut instance); + c57_l75_action_invoke(&mut instance); + c58_l76_action_invoke(&mut instance); + c59_l77_action_invoke(&mut instance); + c60_l78_action_invoke(&mut instance); + c61_l79_action_invoke(&mut instance); + c62_l80_action_invoke(&mut instance); + c63_l81_action_invoke(&mut instance); + c64_l82_action_invoke(&mut instance); + c65_l83_action_invoke(&mut instance); + c66_l84_action_invoke(&mut instance); + c67_l85_action_invoke(&mut instance); + c68_l86_action_invoke(&mut instance); + c69_l87_action_invoke(&mut instance); + c70_l88_action_invoke(&mut instance); + c71_l89_action_invoke(&mut instance); + c72_l90_action_invoke(&mut instance); + c73_l91_assert_return_canonical_nan(&mut instance); + c74_l92_assert_return_arithmetic_nan(&mut instance); + c75_l93_assert_return_canonical_nan(&mut instance); + c76_l94_assert_return_arithmetic_nan(&mut instance); + c77_l95_assert_return_canonical_nan(&mut instance); + c78_l96_assert_return_arithmetic_nan(&mut instance); + c79_l97_assert_return_canonical_nan(&mut instance); + c80_l98_assert_return_arithmetic_nan(&mut instance); + c81_l99_action_invoke(&mut instance); + c82_l100_action_invoke(&mut instance); + c83_l101_action_invoke(&mut instance); + c84_l102_action_invoke(&mut instance); + c85_l103_action_invoke(&mut instance); + c86_l104_action_invoke(&mut instance); + c87_l105_action_invoke(&mut instance); + c88_l106_action_invoke(&mut instance); + c89_l107_action_invoke(&mut instance); + c90_l108_action_invoke(&mut instance); + c91_l109_action_invoke(&mut instance); + c92_l110_action_invoke(&mut instance); + c93_l111_action_invoke(&mut instance); + c94_l112_action_invoke(&mut instance); + c95_l113_action_invoke(&mut instance); + c96_l114_action_invoke(&mut instance); + c97_l115_action_invoke(&mut instance); + c98_l116_action_invoke(&mut instance); + c99_l117_action_invoke(&mut instance); + c100_l118_action_invoke(&mut instance); + c101_l119_action_invoke(&mut instance); + c102_l120_action_invoke(&mut instance); + c103_l121_action_invoke(&mut instance); + c104_l122_action_invoke(&mut instance); + c105_l123_action_invoke(&mut instance); + c106_l124_action_invoke(&mut instance); + c107_l125_action_invoke(&mut instance); + c108_l126_action_invoke(&mut instance); + c109_l127_action_invoke(&mut instance); + c110_l128_action_invoke(&mut instance); + c111_l129_action_invoke(&mut instance); + c112_l130_action_invoke(&mut instance); + c113_l131_assert_return_canonical_nan(&mut instance); + c114_l132_assert_return_arithmetic_nan(&mut instance); + c115_l133_assert_return_canonical_nan(&mut instance); + c116_l134_assert_return_arithmetic_nan(&mut instance); + c117_l135_assert_return_canonical_nan(&mut instance); + c118_l136_assert_return_arithmetic_nan(&mut instance); + c119_l137_assert_return_canonical_nan(&mut instance); + c120_l138_assert_return_arithmetic_nan(&mut instance); + c121_l139_action_invoke(&mut instance); + c122_l140_action_invoke(&mut instance); + c123_l141_action_invoke(&mut instance); + c124_l142_action_invoke(&mut instance); + c125_l143_action_invoke(&mut instance); + c126_l144_action_invoke(&mut instance); + c127_l145_action_invoke(&mut instance); + c128_l146_action_invoke(&mut instance); + c129_l147_action_invoke(&mut instance); + c130_l148_action_invoke(&mut instance); + c131_l149_action_invoke(&mut instance); + c132_l150_action_invoke(&mut instance); + c133_l151_action_invoke(&mut instance); + c134_l152_action_invoke(&mut instance); + c135_l153_action_invoke(&mut instance); + c136_l154_action_invoke(&mut instance); + c137_l155_action_invoke(&mut instance); + c138_l156_action_invoke(&mut instance); + c139_l157_action_invoke(&mut instance); + c140_l158_action_invoke(&mut instance); + c141_l159_action_invoke(&mut instance); + c142_l160_action_invoke(&mut instance); + c143_l161_action_invoke(&mut instance); + c144_l162_action_invoke(&mut instance); + c145_l163_action_invoke(&mut instance); + c146_l164_action_invoke(&mut instance); + c147_l165_action_invoke(&mut instance); + c148_l166_action_invoke(&mut instance); + c149_l167_action_invoke(&mut instance); + c150_l168_action_invoke(&mut instance); + c151_l169_action_invoke(&mut instance); + c152_l170_action_invoke(&mut instance); + c153_l171_assert_return_canonical_nan(&mut instance); + c154_l172_assert_return_arithmetic_nan(&mut instance); + c155_l173_assert_return_canonical_nan(&mut instance); + c156_l174_assert_return_arithmetic_nan(&mut instance); + c157_l175_assert_return_canonical_nan(&mut instance); + c158_l176_assert_return_arithmetic_nan(&mut instance); + c159_l177_assert_return_canonical_nan(&mut instance); + c160_l178_assert_return_arithmetic_nan(&mut instance); + c161_l179_action_invoke(&mut instance); + c162_l180_action_invoke(&mut instance); + c163_l181_action_invoke(&mut instance); + c164_l182_action_invoke(&mut instance); + c165_l183_action_invoke(&mut instance); + c166_l184_action_invoke(&mut instance); + c167_l185_action_invoke(&mut instance); + c168_l186_action_invoke(&mut instance); + c169_l187_action_invoke(&mut instance); + c170_l188_action_invoke(&mut instance); + c171_l189_action_invoke(&mut instance); + c172_l190_action_invoke(&mut instance); + c173_l191_action_invoke(&mut instance); + c174_l192_action_invoke(&mut instance); + c175_l193_action_invoke(&mut instance); + c176_l194_action_invoke(&mut instance); + c177_l195_action_invoke(&mut instance); + c178_l196_action_invoke(&mut instance); + c179_l197_action_invoke(&mut instance); + c180_l198_action_invoke(&mut instance); + c181_l199_action_invoke(&mut instance); + c182_l200_action_invoke(&mut instance); + c183_l201_action_invoke(&mut instance); + c184_l202_action_invoke(&mut instance); + c185_l203_action_invoke(&mut instance); + c186_l204_action_invoke(&mut instance); + c187_l205_action_invoke(&mut instance); + c188_l206_action_invoke(&mut instance); + c189_l207_action_invoke(&mut instance); + c190_l208_action_invoke(&mut instance); + c191_l209_action_invoke(&mut instance); + c192_l210_action_invoke(&mut instance); + c193_l211_assert_return_canonical_nan(&mut instance); + c194_l212_assert_return_arithmetic_nan(&mut instance); + c195_l213_assert_return_canonical_nan(&mut instance); + c196_l214_assert_return_arithmetic_nan(&mut instance); + c197_l215_assert_return_canonical_nan(&mut instance); + c198_l216_assert_return_arithmetic_nan(&mut instance); + c199_l217_assert_return_canonical_nan(&mut instance); + c200_l218_assert_return_arithmetic_nan(&mut instance); + c201_l219_action_invoke(&mut instance); + c202_l220_action_invoke(&mut instance); + c203_l221_action_invoke(&mut instance); + c204_l222_action_invoke(&mut instance); + c205_l223_action_invoke(&mut instance); + c206_l224_action_invoke(&mut instance); + c207_l225_action_invoke(&mut instance); + c208_l226_action_invoke(&mut instance); + c209_l227_action_invoke(&mut instance); + c210_l228_action_invoke(&mut instance); + c211_l229_action_invoke(&mut instance); + c212_l230_action_invoke(&mut instance); + c213_l231_action_invoke(&mut instance); + c214_l232_action_invoke(&mut instance); + c215_l233_action_invoke(&mut instance); + c216_l234_action_invoke(&mut instance); + c217_l235_action_invoke(&mut instance); + c218_l236_action_invoke(&mut instance); + c219_l237_action_invoke(&mut instance); + c220_l238_action_invoke(&mut instance); + c221_l239_action_invoke(&mut instance); + c222_l240_action_invoke(&mut instance); + c223_l241_action_invoke(&mut instance); + c224_l242_action_invoke(&mut instance); + c225_l243_action_invoke(&mut instance); + c226_l244_action_invoke(&mut instance); + c227_l245_action_invoke(&mut instance); + c228_l246_action_invoke(&mut instance); + c229_l247_action_invoke(&mut instance); + c230_l248_action_invoke(&mut instance); + c231_l249_action_invoke(&mut instance); + c232_l250_action_invoke(&mut instance); + c233_l251_assert_return_canonical_nan(&mut instance); + c234_l252_assert_return_arithmetic_nan(&mut instance); + c235_l253_assert_return_canonical_nan(&mut instance); + c236_l254_assert_return_arithmetic_nan(&mut instance); + c237_l255_assert_return_canonical_nan(&mut instance); + c238_l256_assert_return_arithmetic_nan(&mut instance); + c239_l257_assert_return_canonical_nan(&mut instance); + c240_l258_assert_return_arithmetic_nan(&mut instance); + c241_l259_action_invoke(&mut instance); + c242_l260_action_invoke(&mut instance); + c243_l261_action_invoke(&mut instance); + c244_l262_action_invoke(&mut instance); + c245_l263_action_invoke(&mut instance); + c246_l264_action_invoke(&mut instance); + c247_l265_action_invoke(&mut instance); + c248_l266_action_invoke(&mut instance); + c249_l267_action_invoke(&mut instance); + c250_l268_action_invoke(&mut instance); + c251_l269_action_invoke(&mut instance); + c252_l270_action_invoke(&mut instance); + c253_l271_action_invoke(&mut instance); + c254_l272_action_invoke(&mut instance); + c255_l273_action_invoke(&mut instance); + c256_l274_action_invoke(&mut instance); + c257_l275_action_invoke(&mut instance); + c258_l276_action_invoke(&mut instance); + c259_l277_action_invoke(&mut instance); + c260_l278_action_invoke(&mut instance); + c261_l279_action_invoke(&mut instance); + c262_l280_action_invoke(&mut instance); + c263_l281_action_invoke(&mut instance); + c264_l282_action_invoke(&mut instance); + c265_l283_action_invoke(&mut instance); + c266_l284_action_invoke(&mut instance); + c267_l285_action_invoke(&mut instance); + c268_l286_action_invoke(&mut instance); + c269_l287_action_invoke(&mut instance); + c270_l288_action_invoke(&mut instance); + c271_l289_action_invoke(&mut instance); + c272_l290_action_invoke(&mut instance); + c273_l291_assert_return_canonical_nan(&mut instance); + c274_l292_assert_return_arithmetic_nan(&mut instance); + c275_l293_assert_return_canonical_nan(&mut instance); + c276_l294_assert_return_arithmetic_nan(&mut instance); + c277_l295_assert_return_canonical_nan(&mut instance); + c278_l296_assert_return_arithmetic_nan(&mut instance); + c279_l297_assert_return_canonical_nan(&mut instance); + c280_l298_assert_return_arithmetic_nan(&mut instance); + c281_l299_action_invoke(&mut instance); + c282_l300_action_invoke(&mut instance); + c283_l301_action_invoke(&mut instance); + c284_l302_action_invoke(&mut instance); + c285_l303_action_invoke(&mut instance); + c286_l304_action_invoke(&mut instance); + c287_l305_action_invoke(&mut instance); + c288_l306_action_invoke(&mut instance); + c289_l307_action_invoke(&mut instance); + c290_l308_action_invoke(&mut instance); + c291_l309_action_invoke(&mut instance); + c292_l310_action_invoke(&mut instance); + c293_l311_action_invoke(&mut instance); + c294_l312_action_invoke(&mut instance); + c295_l313_action_invoke(&mut instance); + c296_l314_action_invoke(&mut instance); + c297_l315_action_invoke(&mut instance); + c298_l316_action_invoke(&mut instance); + c299_l317_action_invoke(&mut instance); + c300_l318_action_invoke(&mut instance); + c301_l319_action_invoke(&mut instance); + c302_l320_action_invoke(&mut instance); + c303_l321_action_invoke(&mut instance); + c304_l322_action_invoke(&mut instance); + c305_l323_action_invoke(&mut instance); + c306_l324_action_invoke(&mut instance); + c307_l325_action_invoke(&mut instance); + c308_l326_action_invoke(&mut instance); + c309_l327_action_invoke(&mut instance); + c310_l328_assert_return_canonical_nan(&mut instance); + c311_l329_assert_return_canonical_nan(&mut instance); + c312_l330_action_invoke(&mut instance); + c313_l331_assert_return_canonical_nan(&mut instance); + c314_l332_assert_return_arithmetic_nan(&mut instance); + c315_l333_assert_return_canonical_nan(&mut instance); + c316_l334_assert_return_arithmetic_nan(&mut instance); + c317_l335_assert_return_canonical_nan(&mut instance); + c318_l336_assert_return_arithmetic_nan(&mut instance); + c319_l337_assert_return_canonical_nan(&mut instance); + c320_l338_assert_return_arithmetic_nan(&mut instance); + c321_l339_assert_return_canonical_nan(&mut instance); + c322_l340_assert_return_arithmetic_nan(&mut instance); + c323_l341_assert_return_canonical_nan(&mut instance); + c324_l342_assert_return_arithmetic_nan(&mut instance); + c325_l343_assert_return_canonical_nan(&mut instance); + c326_l344_assert_return_arithmetic_nan(&mut instance); + c327_l345_assert_return_canonical_nan(&mut instance); + c328_l346_assert_return_arithmetic_nan(&mut instance); + c329_l347_assert_return_canonical_nan(&mut instance); + c330_l348_assert_return_arithmetic_nan(&mut instance); + c331_l349_assert_return_canonical_nan(&mut instance); + c332_l350_assert_return_arithmetic_nan(&mut instance); + c333_l351_assert_return_canonical_nan(&mut instance); + c334_l352_assert_return_arithmetic_nan(&mut instance); + c335_l353_assert_return_canonical_nan(&mut instance); + c336_l354_assert_return_arithmetic_nan(&mut instance); + c337_l355_assert_return_canonical_nan(&mut instance); + c338_l356_assert_return_arithmetic_nan(&mut instance); + c339_l357_assert_return_canonical_nan(&mut instance); + c340_l358_assert_return_arithmetic_nan(&mut instance); + c341_l359_assert_return_canonical_nan(&mut instance); + c342_l360_assert_return_arithmetic_nan(&mut instance); + c343_l361_assert_return_canonical_nan(&mut instance); + c344_l362_assert_return_arithmetic_nan(&mut instance); + c345_l363_assert_return_canonical_nan(&mut instance); + c346_l364_assert_return_arithmetic_nan(&mut instance); + c347_l365_assert_return_canonical_nan(&mut instance); + c348_l366_assert_return_arithmetic_nan(&mut instance); + c349_l367_assert_return_canonical_nan(&mut instance); + c350_l368_assert_return_arithmetic_nan(&mut instance); + c351_l369_assert_return_canonical_nan(&mut instance); + c352_l370_assert_return_arithmetic_nan(&mut instance); + c353_l371_assert_return_canonical_nan(&mut instance); + c354_l372_assert_return_arithmetic_nan(&mut instance); + c355_l373_assert_return_canonical_nan(&mut instance); + c356_l374_assert_return_arithmetic_nan(&mut instance); + c357_l375_assert_return_canonical_nan(&mut instance); + c358_l376_assert_return_arithmetic_nan(&mut instance); + c359_l377_assert_return_canonical_nan(&mut instance); + c360_l378_assert_return_arithmetic_nan(&mut instance); + c361_l379_assert_return_canonical_nan(&mut instance); + c362_l380_assert_return_arithmetic_nan(&mut instance); + c363_l381_assert_return_canonical_nan(&mut instance); + c364_l382_assert_return_arithmetic_nan(&mut instance); + c365_l383_assert_return_canonical_nan(&mut instance); + c366_l384_assert_return_arithmetic_nan(&mut instance); + c367_l385_assert_return_canonical_nan(&mut instance); + c368_l386_assert_return_arithmetic_nan(&mut instance); + c369_l387_assert_return_canonical_nan(&mut instance); + c370_l388_assert_return_arithmetic_nan(&mut instance); + c371_l389_assert_return_canonical_nan(&mut instance); + c372_l390_assert_return_arithmetic_nan(&mut instance); + c373_l391_assert_return_canonical_nan(&mut instance); + c374_l392_assert_return_arithmetic_nan(&mut instance); + c375_l393_assert_return_canonical_nan(&mut instance); + c376_l394_assert_return_arithmetic_nan(&mut instance); + c377_l395_assert_return_canonical_nan(&mut instance); + c378_l396_assert_return_arithmetic_nan(&mut instance); + c379_l397_assert_return_canonical_nan(&mut instance); + c380_l398_assert_return_arithmetic_nan(&mut instance); + c381_l399_assert_return_canonical_nan(&mut instance); + c382_l400_assert_return_arithmetic_nan(&mut instance); + c383_l401_assert_return_canonical_nan(&mut instance); + c384_l402_assert_return_arithmetic_nan(&mut instance); + c385_l403_assert_return_canonical_nan(&mut instance); + c386_l404_assert_return_arithmetic_nan(&mut instance); + c387_l405_assert_return_arithmetic_nan(&mut instance); + c388_l406_assert_return_arithmetic_nan(&mut instance); + c389_l407_assert_return_canonical_nan(&mut instance); + c390_l408_assert_return_arithmetic_nan(&mut instance); + c391_l409_assert_return_arithmetic_nan(&mut instance); + c392_l410_assert_return_arithmetic_nan(&mut instance); + c393_l411_assert_return_canonical_nan(&mut instance); + c394_l412_assert_return_arithmetic_nan(&mut instance); + c395_l413_assert_return_arithmetic_nan(&mut instance); + c396_l414_assert_return_arithmetic_nan(&mut instance); + c397_l415_assert_return_canonical_nan(&mut instance); + c398_l416_assert_return_arithmetic_nan(&mut instance); + c399_l417_assert_return_arithmetic_nan(&mut instance); + c400_l418_assert_return_arithmetic_nan(&mut instance); + c401_l419_action_invoke(&mut instance); + c402_l420_action_invoke(&mut instance); + c403_l421_action_invoke(&mut instance); + c404_l422_action_invoke(&mut instance); + c405_l423_action_invoke(&mut instance); + c406_l424_action_invoke(&mut instance); + c407_l425_action_invoke(&mut instance); + c408_l426_action_invoke(&mut instance); + c409_l427_action_invoke(&mut instance); + c410_l428_action_invoke(&mut instance); + c411_l429_action_invoke(&mut instance); + c412_l430_action_invoke(&mut instance); + c413_l431_action_invoke(&mut instance); + c414_l432_action_invoke(&mut instance); + c415_l433_action_invoke(&mut instance); + c416_l434_action_invoke(&mut instance); + c417_l435_action_invoke(&mut instance); + c418_l436_action_invoke(&mut instance); + c419_l437_action_invoke(&mut instance); + c420_l438_action_invoke(&mut instance); + c421_l439_action_invoke(&mut instance); + c422_l440_action_invoke(&mut instance); + c423_l441_action_invoke(&mut instance); + c424_l442_action_invoke(&mut instance); + c425_l443_action_invoke(&mut instance); + c426_l444_action_invoke(&mut instance); + c427_l445_action_invoke(&mut instance); + c428_l446_action_invoke(&mut instance); + c429_l447_action_invoke(&mut instance); + c430_l448_action_invoke(&mut instance); + c431_l449_action_invoke(&mut instance); + c432_l450_action_invoke(&mut instance); + c433_l451_assert_return_canonical_nan(&mut instance); + c434_l452_assert_return_arithmetic_nan(&mut instance); + c435_l453_assert_return_canonical_nan(&mut instance); + c436_l454_assert_return_arithmetic_nan(&mut instance); + c437_l455_assert_return_canonical_nan(&mut instance); + c438_l456_assert_return_arithmetic_nan(&mut instance); + c439_l457_assert_return_canonical_nan(&mut instance); + c440_l458_assert_return_arithmetic_nan(&mut instance); + c441_l459_action_invoke(&mut instance); + c442_l460_action_invoke(&mut instance); + c443_l461_action_invoke(&mut instance); + c444_l462_action_invoke(&mut instance); + c445_l463_action_invoke(&mut instance); + c446_l464_action_invoke(&mut instance); + c447_l465_action_invoke(&mut instance); + c448_l466_action_invoke(&mut instance); + c449_l467_action_invoke(&mut instance); + c450_l468_action_invoke(&mut instance); + c451_l469_action_invoke(&mut instance); + c452_l470_action_invoke(&mut instance); + c453_l471_action_invoke(&mut instance); + c454_l472_action_invoke(&mut instance); + c455_l473_action_invoke(&mut instance); + c456_l474_action_invoke(&mut instance); + c457_l475_action_invoke(&mut instance); + c458_l476_action_invoke(&mut instance); + c459_l477_action_invoke(&mut instance); + c460_l478_action_invoke(&mut instance); + c461_l479_action_invoke(&mut instance); + c462_l480_action_invoke(&mut instance); + c463_l481_action_invoke(&mut instance); + c464_l482_action_invoke(&mut instance); + c465_l483_action_invoke(&mut instance); + c466_l484_action_invoke(&mut instance); + c467_l485_action_invoke(&mut instance); + c468_l486_action_invoke(&mut instance); + c469_l487_action_invoke(&mut instance); + c470_l488_action_invoke(&mut instance); + c471_l489_action_invoke(&mut instance); + c472_l490_action_invoke(&mut instance); + c473_l491_assert_return_canonical_nan(&mut instance); + c474_l492_assert_return_arithmetic_nan(&mut instance); + c475_l493_assert_return_canonical_nan(&mut instance); + c476_l494_assert_return_arithmetic_nan(&mut instance); + c477_l495_assert_return_canonical_nan(&mut instance); + c478_l496_assert_return_arithmetic_nan(&mut instance); + c479_l497_assert_return_canonical_nan(&mut instance); + c480_l498_assert_return_arithmetic_nan(&mut instance); + c481_l499_action_invoke(&mut instance); + c482_l500_action_invoke(&mut instance); + c483_l501_action_invoke(&mut instance); + c484_l502_action_invoke(&mut instance); + c485_l503_action_invoke(&mut instance); + c486_l504_action_invoke(&mut instance); + c487_l505_action_invoke(&mut instance); + c488_l506_action_invoke(&mut instance); + c489_l507_action_invoke(&mut instance); + c490_l508_action_invoke(&mut instance); + c491_l509_action_invoke(&mut instance); + c492_l510_action_invoke(&mut instance); + c493_l511_action_invoke(&mut instance); + c494_l512_action_invoke(&mut instance); + c495_l513_action_invoke(&mut instance); + c496_l514_action_invoke(&mut instance); + c497_l515_action_invoke(&mut instance); + c498_l516_action_invoke(&mut instance); + c499_l517_action_invoke(&mut instance); + c500_l518_action_invoke(&mut instance); + c501_l519_action_invoke(&mut instance); + c502_l520_action_invoke(&mut instance); + c503_l521_action_invoke(&mut instance); + c504_l522_action_invoke(&mut instance); + c505_l523_action_invoke(&mut instance); + c506_l524_action_invoke(&mut instance); + c507_l525_action_invoke(&mut instance); + c508_l526_action_invoke(&mut instance); + c509_l527_action_invoke(&mut instance); + c510_l528_action_invoke(&mut instance); + c511_l529_action_invoke(&mut instance); + c512_l530_action_invoke(&mut instance); + c513_l531_assert_return_canonical_nan(&mut instance); + c514_l532_assert_return_arithmetic_nan(&mut instance); + c515_l533_assert_return_canonical_nan(&mut instance); + c516_l534_assert_return_arithmetic_nan(&mut instance); + c517_l535_assert_return_canonical_nan(&mut instance); + c518_l536_assert_return_arithmetic_nan(&mut instance); + c519_l537_assert_return_canonical_nan(&mut instance); + c520_l538_assert_return_arithmetic_nan(&mut instance); + c521_l539_action_invoke(&mut instance); + c522_l540_action_invoke(&mut instance); + c523_l541_action_invoke(&mut instance); + c524_l542_action_invoke(&mut instance); + c525_l543_action_invoke(&mut instance); + c526_l544_action_invoke(&mut instance); + c527_l545_action_invoke(&mut instance); + c528_l546_action_invoke(&mut instance); + c529_l547_action_invoke(&mut instance); + c530_l548_action_invoke(&mut instance); + c531_l549_action_invoke(&mut instance); + c532_l550_action_invoke(&mut instance); + c533_l551_action_invoke(&mut instance); + c534_l552_action_invoke(&mut instance); + c535_l553_action_invoke(&mut instance); + c536_l554_action_invoke(&mut instance); + c537_l555_action_invoke(&mut instance); + c538_l556_action_invoke(&mut instance); + c539_l557_action_invoke(&mut instance); + c540_l558_action_invoke(&mut instance); + c541_l559_action_invoke(&mut instance); + c542_l560_action_invoke(&mut instance); + c543_l561_action_invoke(&mut instance); + c544_l562_action_invoke(&mut instance); + c545_l563_action_invoke(&mut instance); + c546_l564_action_invoke(&mut instance); + c547_l565_action_invoke(&mut instance); + c548_l566_action_invoke(&mut instance); + c549_l567_action_invoke(&mut instance); + c550_l568_action_invoke(&mut instance); + c551_l569_action_invoke(&mut instance); + c552_l570_action_invoke(&mut instance); + c553_l571_assert_return_canonical_nan(&mut instance); + c554_l572_assert_return_arithmetic_nan(&mut instance); + c555_l573_assert_return_canonical_nan(&mut instance); + c556_l574_assert_return_arithmetic_nan(&mut instance); + c557_l575_assert_return_canonical_nan(&mut instance); + c558_l576_assert_return_arithmetic_nan(&mut instance); + c559_l577_assert_return_canonical_nan(&mut instance); + c560_l578_assert_return_arithmetic_nan(&mut instance); + c561_l579_action_invoke(&mut instance); + c562_l580_action_invoke(&mut instance); + c563_l581_action_invoke(&mut instance); + c564_l582_action_invoke(&mut instance); + c565_l583_action_invoke(&mut instance); + c566_l584_action_invoke(&mut instance); + c567_l585_action_invoke(&mut instance); + c568_l586_action_invoke(&mut instance); + c569_l587_action_invoke(&mut instance); + c570_l588_action_invoke(&mut instance); + c571_l589_action_invoke(&mut instance); + c572_l590_action_invoke(&mut instance); + c573_l591_action_invoke(&mut instance); + c574_l592_action_invoke(&mut instance); + c575_l593_action_invoke(&mut instance); + c576_l594_action_invoke(&mut instance); + c577_l595_action_invoke(&mut instance); + c578_l596_action_invoke(&mut instance); + c579_l597_action_invoke(&mut instance); + c580_l598_action_invoke(&mut instance); + c581_l599_action_invoke(&mut instance); + c582_l600_action_invoke(&mut instance); + c583_l601_action_invoke(&mut instance); + c584_l602_action_invoke(&mut instance); + c585_l603_action_invoke(&mut instance); + c586_l604_action_invoke(&mut instance); + c587_l605_action_invoke(&mut instance); + c588_l606_action_invoke(&mut instance); + c589_l607_action_invoke(&mut instance); + c590_l608_action_invoke(&mut instance); + c591_l609_action_invoke(&mut instance); + c592_l610_action_invoke(&mut instance); + c593_l611_assert_return_canonical_nan(&mut instance); + c594_l612_assert_return_arithmetic_nan(&mut instance); + c595_l613_assert_return_canonical_nan(&mut instance); + c596_l614_assert_return_arithmetic_nan(&mut instance); + c597_l615_assert_return_canonical_nan(&mut instance); + c598_l616_assert_return_arithmetic_nan(&mut instance); + c599_l617_assert_return_canonical_nan(&mut instance); + c600_l618_assert_return_arithmetic_nan(&mut instance); + c601_l619_action_invoke(&mut instance); + c602_l620_action_invoke(&mut instance); + c603_l621_action_invoke(&mut instance); + c604_l622_action_invoke(&mut instance); + c605_l623_action_invoke(&mut instance); + c606_l624_action_invoke(&mut instance); + c607_l625_action_invoke(&mut instance); + c608_l626_action_invoke(&mut instance); + c609_l627_action_invoke(&mut instance); + c610_l628_action_invoke(&mut instance); + c611_l629_action_invoke(&mut instance); + c612_l630_action_invoke(&mut instance); + c613_l631_action_invoke(&mut instance); + c614_l632_action_invoke(&mut instance); + c615_l633_action_invoke(&mut instance); + c616_l634_action_invoke(&mut instance); + c617_l635_action_invoke(&mut instance); + c618_l636_action_invoke(&mut instance); + c619_l637_action_invoke(&mut instance); + c620_l638_action_invoke(&mut instance); + c621_l639_action_invoke(&mut instance); + c622_l640_action_invoke(&mut instance); + c623_l641_action_invoke(&mut instance); + c624_l642_action_invoke(&mut instance); + c625_l643_action_invoke(&mut instance); + c626_l644_action_invoke(&mut instance); + c627_l645_action_invoke(&mut instance); + c628_l646_action_invoke(&mut instance); + c629_l647_action_invoke(&mut instance); + c630_l648_action_invoke(&mut instance); + c631_l649_action_invoke(&mut instance); + c632_l650_action_invoke(&mut instance); + c633_l651_assert_return_canonical_nan(&mut instance); + c634_l652_assert_return_arithmetic_nan(&mut instance); + c635_l653_assert_return_canonical_nan(&mut instance); + c636_l654_assert_return_arithmetic_nan(&mut instance); + c637_l655_assert_return_canonical_nan(&mut instance); + c638_l656_assert_return_arithmetic_nan(&mut instance); + c639_l657_assert_return_canonical_nan(&mut instance); + c640_l658_assert_return_arithmetic_nan(&mut instance); + c641_l659_action_invoke(&mut instance); + c642_l660_action_invoke(&mut instance); + c643_l661_action_invoke(&mut instance); + c644_l662_action_invoke(&mut instance); + c645_l663_action_invoke(&mut instance); + c646_l664_action_invoke(&mut instance); + c647_l665_action_invoke(&mut instance); + c648_l666_action_invoke(&mut instance); + c649_l667_action_invoke(&mut instance); + c650_l668_action_invoke(&mut instance); + c651_l669_action_invoke(&mut instance); + c652_l670_action_invoke(&mut instance); + c653_l671_action_invoke(&mut instance); + c654_l672_action_invoke(&mut instance); + c655_l673_action_invoke(&mut instance); + c656_l674_action_invoke(&mut instance); + c657_l675_action_invoke(&mut instance); + c658_l676_action_invoke(&mut instance); + c659_l677_action_invoke(&mut instance); + c660_l678_action_invoke(&mut instance); + c661_l679_action_invoke(&mut instance); + c662_l680_action_invoke(&mut instance); + c663_l681_action_invoke(&mut instance); + c664_l682_action_invoke(&mut instance); + c665_l683_action_invoke(&mut instance); + c666_l684_action_invoke(&mut instance); + c667_l685_action_invoke(&mut instance); + c668_l686_action_invoke(&mut instance); + c669_l687_action_invoke(&mut instance); + c670_l688_action_invoke(&mut instance); + c671_l689_action_invoke(&mut instance); + c672_l690_action_invoke(&mut instance); + c673_l691_assert_return_canonical_nan(&mut instance); + c674_l692_assert_return_arithmetic_nan(&mut instance); + c675_l693_assert_return_canonical_nan(&mut instance); + c676_l694_assert_return_arithmetic_nan(&mut instance); + c677_l695_assert_return_canonical_nan(&mut instance); + c678_l696_assert_return_arithmetic_nan(&mut instance); + c679_l697_assert_return_canonical_nan(&mut instance); + c680_l698_assert_return_arithmetic_nan(&mut instance); + c681_l699_action_invoke(&mut instance); + c682_l700_action_invoke(&mut instance); + c683_l701_action_invoke(&mut instance); + c684_l702_action_invoke(&mut instance); + c685_l703_action_invoke(&mut instance); + c686_l704_action_invoke(&mut instance); + c687_l705_action_invoke(&mut instance); + c688_l706_action_invoke(&mut instance); + c689_l707_action_invoke(&mut instance); + c690_l708_action_invoke(&mut instance); + c691_l709_action_invoke(&mut instance); + c692_l710_action_invoke(&mut instance); + c693_l711_action_invoke(&mut instance); + c694_l712_action_invoke(&mut instance); + c695_l713_action_invoke(&mut instance); + c696_l714_action_invoke(&mut instance); + c697_l715_action_invoke(&mut instance); + c698_l716_action_invoke(&mut instance); + c699_l717_action_invoke(&mut instance); + c700_l718_action_invoke(&mut instance); + c701_l719_action_invoke(&mut instance); + c702_l720_action_invoke(&mut instance); + c703_l721_action_invoke(&mut instance); + c704_l722_action_invoke(&mut instance); + c705_l723_action_invoke(&mut instance); + c706_l724_action_invoke(&mut instance); + c707_l725_action_invoke(&mut instance); + c708_l726_action_invoke(&mut instance); + c709_l727_assert_return_canonical_nan(&mut instance); + c710_l728_action_invoke(&mut instance); + c711_l729_action_invoke(&mut instance); + c712_l730_assert_return_canonical_nan(&mut instance); + c713_l731_assert_return_canonical_nan(&mut instance); + c714_l732_assert_return_arithmetic_nan(&mut instance); + c715_l733_assert_return_canonical_nan(&mut instance); + c716_l734_assert_return_arithmetic_nan(&mut instance); + c717_l735_assert_return_canonical_nan(&mut instance); + c718_l736_assert_return_arithmetic_nan(&mut instance); + c719_l737_assert_return_canonical_nan(&mut instance); + c720_l738_assert_return_arithmetic_nan(&mut instance); + c721_l739_assert_return_canonical_nan(&mut instance); + c722_l740_assert_return_arithmetic_nan(&mut instance); + c723_l741_assert_return_canonical_nan(&mut instance); + c724_l742_assert_return_arithmetic_nan(&mut instance); + c725_l743_assert_return_canonical_nan(&mut instance); + c726_l744_assert_return_arithmetic_nan(&mut instance); + c727_l745_assert_return_canonical_nan(&mut instance); + c728_l746_assert_return_arithmetic_nan(&mut instance); + c729_l747_assert_return_canonical_nan(&mut instance); + c730_l748_assert_return_arithmetic_nan(&mut instance); + c731_l749_assert_return_canonical_nan(&mut instance); + c732_l750_assert_return_arithmetic_nan(&mut instance); + c733_l751_assert_return_canonical_nan(&mut instance); + c734_l752_assert_return_arithmetic_nan(&mut instance); + c735_l753_assert_return_canonical_nan(&mut instance); + c736_l754_assert_return_arithmetic_nan(&mut instance); + c737_l755_assert_return_canonical_nan(&mut instance); + c738_l756_assert_return_arithmetic_nan(&mut instance); + c739_l757_assert_return_canonical_nan(&mut instance); + c740_l758_assert_return_arithmetic_nan(&mut instance); + c741_l759_assert_return_canonical_nan(&mut instance); + c742_l760_assert_return_arithmetic_nan(&mut instance); + c743_l761_assert_return_canonical_nan(&mut instance); + c744_l762_assert_return_arithmetic_nan(&mut instance); + c745_l763_assert_return_canonical_nan(&mut instance); + c746_l764_assert_return_arithmetic_nan(&mut instance); + c747_l765_assert_return_canonical_nan(&mut instance); + c748_l766_assert_return_arithmetic_nan(&mut instance); + c749_l767_assert_return_canonical_nan(&mut instance); + c750_l768_assert_return_arithmetic_nan(&mut instance); + c751_l769_assert_return_canonical_nan(&mut instance); + c752_l770_assert_return_arithmetic_nan(&mut instance); + c753_l771_assert_return_canonical_nan(&mut instance); + c754_l772_assert_return_arithmetic_nan(&mut instance); + c755_l773_assert_return_canonical_nan(&mut instance); + c756_l774_assert_return_arithmetic_nan(&mut instance); + c757_l775_assert_return_canonical_nan(&mut instance); + c758_l776_assert_return_arithmetic_nan(&mut instance); + c759_l777_assert_return_canonical_nan(&mut instance); + c760_l778_assert_return_arithmetic_nan(&mut instance); + c761_l779_assert_return_canonical_nan(&mut instance); + c762_l780_assert_return_arithmetic_nan(&mut instance); + c763_l781_assert_return_canonical_nan(&mut instance); + c764_l782_assert_return_arithmetic_nan(&mut instance); + c765_l783_assert_return_canonical_nan(&mut instance); + c766_l784_assert_return_arithmetic_nan(&mut instance); + c767_l785_assert_return_canonical_nan(&mut instance); + c768_l786_assert_return_arithmetic_nan(&mut instance); + c769_l787_assert_return_canonical_nan(&mut instance); + c770_l788_assert_return_arithmetic_nan(&mut instance); + c771_l789_assert_return_canonical_nan(&mut instance); + c772_l790_assert_return_arithmetic_nan(&mut instance); + c773_l791_assert_return_canonical_nan(&mut instance); + c774_l792_assert_return_arithmetic_nan(&mut instance); + c775_l793_assert_return_canonical_nan(&mut instance); + c776_l794_assert_return_arithmetic_nan(&mut instance); + c777_l795_assert_return_canonical_nan(&mut instance); + c778_l796_assert_return_arithmetic_nan(&mut instance); + c779_l797_assert_return_canonical_nan(&mut instance); + c780_l798_assert_return_arithmetic_nan(&mut instance); + c781_l799_assert_return_canonical_nan(&mut instance); + c782_l800_assert_return_arithmetic_nan(&mut instance); + c783_l801_assert_return_canonical_nan(&mut instance); + c784_l802_assert_return_arithmetic_nan(&mut instance); + c785_l803_assert_return_canonical_nan(&mut instance); + c786_l804_assert_return_arithmetic_nan(&mut instance); + c787_l805_assert_return_arithmetic_nan(&mut instance); + c788_l806_assert_return_arithmetic_nan(&mut instance); + c789_l807_assert_return_canonical_nan(&mut instance); + c790_l808_assert_return_arithmetic_nan(&mut instance); + c791_l809_assert_return_arithmetic_nan(&mut instance); + c792_l810_assert_return_arithmetic_nan(&mut instance); + c793_l811_assert_return_canonical_nan(&mut instance); + c794_l812_assert_return_arithmetic_nan(&mut instance); + c795_l813_assert_return_arithmetic_nan(&mut instance); + c796_l814_assert_return_arithmetic_nan(&mut instance); + c797_l815_assert_return_canonical_nan(&mut instance); + c798_l816_assert_return_arithmetic_nan(&mut instance); + c799_l817_assert_return_arithmetic_nan(&mut instance); + c800_l818_assert_return_arithmetic_nan(&mut instance); + c801_l819_action_invoke(&mut instance); + c802_l820_action_invoke(&mut instance); + c803_l821_action_invoke(&mut instance); + c804_l822_action_invoke(&mut instance); + c805_l823_action_invoke(&mut instance); + c806_l824_action_invoke(&mut instance); + c807_l825_action_invoke(&mut instance); + c808_l826_action_invoke(&mut instance); + c809_l827_action_invoke(&mut instance); + c810_l828_action_invoke(&mut instance); + c811_l829_action_invoke(&mut instance); + c812_l830_action_invoke(&mut instance); + c813_l831_action_invoke(&mut instance); + c814_l832_action_invoke(&mut instance); + c815_l833_action_invoke(&mut instance); + c816_l834_action_invoke(&mut instance); + c817_l835_action_invoke(&mut instance); + c818_l836_action_invoke(&mut instance); + c819_l837_action_invoke(&mut instance); + c820_l838_action_invoke(&mut instance); + c821_l839_action_invoke(&mut instance); + c822_l840_action_invoke(&mut instance); + c823_l841_action_invoke(&mut instance); + c824_l842_action_invoke(&mut instance); + c825_l843_action_invoke(&mut instance); + c826_l844_action_invoke(&mut instance); + c827_l845_action_invoke(&mut instance); + c828_l846_action_invoke(&mut instance); + c829_l847_assert_return_canonical_nan(&mut instance); + c830_l848_assert_return_canonical_nan(&mut instance); + c831_l849_assert_return_canonical_nan(&mut instance); + c832_l850_assert_return_canonical_nan(&mut instance); + c833_l851_assert_return_canonical_nan(&mut instance); + c834_l852_assert_return_arithmetic_nan(&mut instance); + c835_l853_assert_return_canonical_nan(&mut instance); + c836_l854_assert_return_arithmetic_nan(&mut instance); + c837_l855_assert_return_canonical_nan(&mut instance); + c838_l856_assert_return_arithmetic_nan(&mut instance); + c839_l857_assert_return_canonical_nan(&mut instance); + c840_l858_assert_return_arithmetic_nan(&mut instance); + c841_l859_action_invoke(&mut instance); + c842_l860_action_invoke(&mut instance); + c843_l861_action_invoke(&mut instance); + c844_l862_action_invoke(&mut instance); + c845_l863_action_invoke(&mut instance); + c846_l864_action_invoke(&mut instance); + c847_l865_action_invoke(&mut instance); + c848_l866_action_invoke(&mut instance); + c849_l867_action_invoke(&mut instance); + c850_l868_action_invoke(&mut instance); + c851_l869_action_invoke(&mut instance); + c852_l870_action_invoke(&mut instance); + c853_l871_action_invoke(&mut instance); + c854_l872_action_invoke(&mut instance); + c855_l873_action_invoke(&mut instance); + c856_l874_action_invoke(&mut instance); + c857_l875_action_invoke(&mut instance); + c858_l876_action_invoke(&mut instance); + c859_l877_action_invoke(&mut instance); + c860_l878_action_invoke(&mut instance); + c861_l879_action_invoke(&mut instance); + c862_l880_action_invoke(&mut instance); + c863_l881_action_invoke(&mut instance); + c864_l882_action_invoke(&mut instance); + c865_l883_action_invoke(&mut instance); + c866_l884_action_invoke(&mut instance); + c867_l885_action_invoke(&mut instance); + c868_l886_action_invoke(&mut instance); + c869_l887_action_invoke(&mut instance); + c870_l888_action_invoke(&mut instance); + c871_l889_action_invoke(&mut instance); + c872_l890_action_invoke(&mut instance); + c873_l891_assert_return_canonical_nan(&mut instance); + c874_l892_assert_return_arithmetic_nan(&mut instance); + c875_l893_assert_return_canonical_nan(&mut instance); + c876_l894_assert_return_arithmetic_nan(&mut instance); + c877_l895_assert_return_canonical_nan(&mut instance); + c878_l896_assert_return_arithmetic_nan(&mut instance); + c879_l897_assert_return_canonical_nan(&mut instance); + c880_l898_assert_return_arithmetic_nan(&mut instance); + c881_l899_action_invoke(&mut instance); + c882_l900_action_invoke(&mut instance); + c883_l901_action_invoke(&mut instance); + c884_l902_action_invoke(&mut instance); + c885_l903_action_invoke(&mut instance); + c886_l904_action_invoke(&mut instance); + c887_l905_action_invoke(&mut instance); + c888_l906_action_invoke(&mut instance); + c889_l907_action_invoke(&mut instance); + c890_l908_action_invoke(&mut instance); + c891_l909_action_invoke(&mut instance); + c892_l910_action_invoke(&mut instance); + c893_l911_action_invoke(&mut instance); + c894_l912_action_invoke(&mut instance); + c895_l913_action_invoke(&mut instance); + c896_l914_action_invoke(&mut instance); + c897_l915_action_invoke(&mut instance); + c898_l916_action_invoke(&mut instance); + c899_l917_action_invoke(&mut instance); + c900_l918_action_invoke(&mut instance); + c901_l919_action_invoke(&mut instance); + c902_l920_action_invoke(&mut instance); + c903_l921_action_invoke(&mut instance); + c904_l922_action_invoke(&mut instance); + c905_l923_action_invoke(&mut instance); + c906_l924_action_invoke(&mut instance); + c907_l925_action_invoke(&mut instance); + c908_l926_action_invoke(&mut instance); + c909_l927_action_invoke(&mut instance); + c910_l928_action_invoke(&mut instance); + c911_l929_action_invoke(&mut instance); + c912_l930_action_invoke(&mut instance); + c913_l931_assert_return_canonical_nan(&mut instance); + c914_l932_assert_return_arithmetic_nan(&mut instance); + c915_l933_assert_return_canonical_nan(&mut instance); + c916_l934_assert_return_arithmetic_nan(&mut instance); + c917_l935_assert_return_canonical_nan(&mut instance); + c918_l936_assert_return_arithmetic_nan(&mut instance); + c919_l937_assert_return_canonical_nan(&mut instance); + c920_l938_assert_return_arithmetic_nan(&mut instance); + c921_l939_action_invoke(&mut instance); + c922_l940_action_invoke(&mut instance); + c923_l941_action_invoke(&mut instance); + c924_l942_action_invoke(&mut instance); + c925_l943_action_invoke(&mut instance); + c926_l944_action_invoke(&mut instance); + c927_l945_action_invoke(&mut instance); + c928_l946_action_invoke(&mut instance); + c929_l947_action_invoke(&mut instance); + c930_l948_action_invoke(&mut instance); + c931_l949_action_invoke(&mut instance); + c932_l950_action_invoke(&mut instance); + c933_l951_action_invoke(&mut instance); + c934_l952_action_invoke(&mut instance); + c935_l953_action_invoke(&mut instance); + c936_l954_action_invoke(&mut instance); + c937_l955_action_invoke(&mut instance); + c938_l956_action_invoke(&mut instance); + c939_l957_action_invoke(&mut instance); + c940_l958_action_invoke(&mut instance); + c941_l959_action_invoke(&mut instance); + c942_l960_action_invoke(&mut instance); + c943_l961_action_invoke(&mut instance); + c944_l962_action_invoke(&mut instance); + c945_l963_action_invoke(&mut instance); + c946_l964_action_invoke(&mut instance); + c947_l965_action_invoke(&mut instance); + c948_l966_action_invoke(&mut instance); + c949_l967_action_invoke(&mut instance); + c950_l968_action_invoke(&mut instance); + c951_l969_action_invoke(&mut instance); + c952_l970_action_invoke(&mut instance); + c953_l971_assert_return_canonical_nan(&mut instance); + c954_l972_assert_return_arithmetic_nan(&mut instance); + c955_l973_assert_return_canonical_nan(&mut instance); + c956_l974_assert_return_arithmetic_nan(&mut instance); + c957_l975_assert_return_canonical_nan(&mut instance); + c958_l976_assert_return_arithmetic_nan(&mut instance); + c959_l977_assert_return_canonical_nan(&mut instance); + c960_l978_assert_return_arithmetic_nan(&mut instance); + c961_l979_action_invoke(&mut instance); + c962_l980_action_invoke(&mut instance); + c963_l981_action_invoke(&mut instance); + c964_l982_action_invoke(&mut instance); + c965_l983_action_invoke(&mut instance); + c966_l984_action_invoke(&mut instance); + c967_l985_action_invoke(&mut instance); + c968_l986_action_invoke(&mut instance); + c969_l987_action_invoke(&mut instance); + c970_l988_action_invoke(&mut instance); + c971_l989_action_invoke(&mut instance); + c972_l990_action_invoke(&mut instance); + c973_l991_action_invoke(&mut instance); + c974_l992_action_invoke(&mut instance); + c975_l993_action_invoke(&mut instance); + c976_l994_action_invoke(&mut instance); + c977_l995_action_invoke(&mut instance); + c978_l996_action_invoke(&mut instance); + c979_l997_action_invoke(&mut instance); + c980_l998_action_invoke(&mut instance); + c981_l999_action_invoke(&mut instance); + c982_l1000_action_invoke(&mut instance); + c983_l1001_action_invoke(&mut instance); + c984_l1002_action_invoke(&mut instance); + c985_l1003_action_invoke(&mut instance); + c986_l1004_action_invoke(&mut instance); + c987_l1005_action_invoke(&mut instance); + c988_l1006_action_invoke(&mut instance); + c989_l1007_action_invoke(&mut instance); + c990_l1008_action_invoke(&mut instance); + c991_l1009_action_invoke(&mut instance); + c992_l1010_action_invoke(&mut instance); + c993_l1011_assert_return_canonical_nan(&mut instance); + c994_l1012_assert_return_arithmetic_nan(&mut instance); + c995_l1013_assert_return_canonical_nan(&mut instance); + c996_l1014_assert_return_arithmetic_nan(&mut instance); + c997_l1015_assert_return_canonical_nan(&mut instance); + c998_l1016_assert_return_arithmetic_nan(&mut instance); + c999_l1017_assert_return_canonical_nan(&mut instance); + c1000_l1018_assert_return_arithmetic_nan(&mut instance); + c1001_l1019_action_invoke(&mut instance); + c1002_l1020_action_invoke(&mut instance); + c1003_l1021_action_invoke(&mut instance); + c1004_l1022_action_invoke(&mut instance); + c1005_l1023_action_invoke(&mut instance); + c1006_l1024_action_invoke(&mut instance); + c1007_l1025_action_invoke(&mut instance); + c1008_l1026_action_invoke(&mut instance); + c1009_l1027_action_invoke(&mut instance); + c1010_l1028_action_invoke(&mut instance); + c1011_l1029_action_invoke(&mut instance); + c1012_l1030_action_invoke(&mut instance); + c1013_l1031_action_invoke(&mut instance); + c1014_l1032_action_invoke(&mut instance); + c1015_l1033_action_invoke(&mut instance); + c1016_l1034_action_invoke(&mut instance); + c1017_l1035_action_invoke(&mut instance); + c1018_l1036_action_invoke(&mut instance); + c1019_l1037_action_invoke(&mut instance); + c1020_l1038_action_invoke(&mut instance); + c1021_l1039_action_invoke(&mut instance); + c1022_l1040_action_invoke(&mut instance); + c1023_l1041_action_invoke(&mut instance); + c1024_l1042_action_invoke(&mut instance); + c1025_l1043_action_invoke(&mut instance); + c1026_l1044_action_invoke(&mut instance); + c1027_l1045_action_invoke(&mut instance); + c1028_l1046_action_invoke(&mut instance); + c1029_l1047_action_invoke(&mut instance); + c1030_l1048_action_invoke(&mut instance); + c1031_l1049_action_invoke(&mut instance); + c1032_l1050_action_invoke(&mut instance); + c1033_l1051_assert_return_canonical_nan(&mut instance); + c1034_l1052_assert_return_arithmetic_nan(&mut instance); + c1035_l1053_assert_return_canonical_nan(&mut instance); + c1036_l1054_assert_return_arithmetic_nan(&mut instance); + c1037_l1055_assert_return_canonical_nan(&mut instance); + c1038_l1056_assert_return_arithmetic_nan(&mut instance); + c1039_l1057_assert_return_canonical_nan(&mut instance); + c1040_l1058_assert_return_arithmetic_nan(&mut instance); + c1041_l1059_action_invoke(&mut instance); + c1042_l1060_action_invoke(&mut instance); + c1043_l1061_action_invoke(&mut instance); + c1044_l1062_action_invoke(&mut instance); + c1045_l1063_action_invoke(&mut instance); + c1046_l1064_action_invoke(&mut instance); + c1047_l1065_action_invoke(&mut instance); + c1048_l1066_action_invoke(&mut instance); + c1049_l1067_action_invoke(&mut instance); + c1050_l1068_action_invoke(&mut instance); + c1051_l1069_action_invoke(&mut instance); + c1052_l1070_action_invoke(&mut instance); + c1053_l1071_action_invoke(&mut instance); + c1054_l1072_action_invoke(&mut instance); + c1055_l1073_action_invoke(&mut instance); + c1056_l1074_action_invoke(&mut instance); + c1057_l1075_action_invoke(&mut instance); + c1058_l1076_action_invoke(&mut instance); + c1059_l1077_action_invoke(&mut instance); + c1060_l1078_action_invoke(&mut instance); + c1061_l1079_action_invoke(&mut instance); + c1062_l1080_action_invoke(&mut instance); + c1063_l1081_action_invoke(&mut instance); + c1064_l1082_action_invoke(&mut instance); + c1065_l1083_action_invoke(&mut instance); + c1066_l1084_action_invoke(&mut instance); + c1067_l1085_action_invoke(&mut instance); + c1068_l1086_action_invoke(&mut instance); + c1069_l1087_action_invoke(&mut instance); + c1070_l1088_action_invoke(&mut instance); + c1071_l1089_action_invoke(&mut instance); + c1072_l1090_action_invoke(&mut instance); + c1073_l1091_assert_return_canonical_nan(&mut instance); + c1074_l1092_assert_return_arithmetic_nan(&mut instance); + c1075_l1093_assert_return_canonical_nan(&mut instance); + c1076_l1094_assert_return_arithmetic_nan(&mut instance); + c1077_l1095_assert_return_canonical_nan(&mut instance); + c1078_l1096_assert_return_arithmetic_nan(&mut instance); + c1079_l1097_assert_return_canonical_nan(&mut instance); + c1080_l1098_assert_return_arithmetic_nan(&mut instance); + c1081_l1099_assert_return_canonical_nan(&mut instance); + c1082_l1100_assert_return_canonical_nan(&mut instance); + c1083_l1101_assert_return_canonical_nan(&mut instance); + c1084_l1102_assert_return_canonical_nan(&mut instance); + c1085_l1103_action_invoke(&mut instance); + c1086_l1104_action_invoke(&mut instance); + c1087_l1105_action_invoke(&mut instance); + c1088_l1106_action_invoke(&mut instance); + c1089_l1107_action_invoke(&mut instance); + c1090_l1108_action_invoke(&mut instance); + c1091_l1109_action_invoke(&mut instance); + c1092_l1110_action_invoke(&mut instance); + c1093_l1111_action_invoke(&mut instance); + c1094_l1112_action_invoke(&mut instance); + c1095_l1113_action_invoke(&mut instance); + c1096_l1114_action_invoke(&mut instance); + c1097_l1115_action_invoke(&mut instance); + c1098_l1116_action_invoke(&mut instance); + c1099_l1117_action_invoke(&mut instance); + c1100_l1118_action_invoke(&mut instance); + c1101_l1119_action_invoke(&mut instance); + c1102_l1120_action_invoke(&mut instance); + c1103_l1121_action_invoke(&mut instance); + c1104_l1122_action_invoke(&mut instance); + c1105_l1123_action_invoke(&mut instance); + c1106_l1124_action_invoke(&mut instance); + c1107_l1125_action_invoke(&mut instance); + c1108_l1126_action_invoke(&mut instance); + c1109_l1127_action_invoke(&mut instance); + c1110_l1128_action_invoke(&mut instance); + c1111_l1129_action_invoke(&mut instance); + c1112_l1130_action_invoke(&mut instance); + c1113_l1131_assert_return_canonical_nan(&mut instance); + c1114_l1132_assert_return_arithmetic_nan(&mut instance); + c1115_l1133_assert_return_canonical_nan(&mut instance); + c1116_l1134_assert_return_arithmetic_nan(&mut instance); + c1117_l1135_assert_return_canonical_nan(&mut instance); + c1118_l1136_assert_return_arithmetic_nan(&mut instance); + c1119_l1137_assert_return_canonical_nan(&mut instance); + c1120_l1138_assert_return_arithmetic_nan(&mut instance); + c1121_l1139_assert_return_canonical_nan(&mut instance); + c1122_l1140_assert_return_arithmetic_nan(&mut instance); + c1123_l1141_assert_return_canonical_nan(&mut instance); + c1124_l1142_assert_return_arithmetic_nan(&mut instance); + c1125_l1143_assert_return_canonical_nan(&mut instance); + c1126_l1144_assert_return_arithmetic_nan(&mut instance); + c1127_l1145_assert_return_canonical_nan(&mut instance); + c1128_l1146_assert_return_arithmetic_nan(&mut instance); + c1129_l1147_assert_return_canonical_nan(&mut instance); + c1130_l1148_assert_return_arithmetic_nan(&mut instance); + c1131_l1149_assert_return_canonical_nan(&mut instance); + c1132_l1150_assert_return_arithmetic_nan(&mut instance); + c1133_l1151_assert_return_canonical_nan(&mut instance); + c1134_l1152_assert_return_arithmetic_nan(&mut instance); + c1135_l1153_assert_return_canonical_nan(&mut instance); + c1136_l1154_assert_return_arithmetic_nan(&mut instance); + c1137_l1155_assert_return_canonical_nan(&mut instance); + c1138_l1156_assert_return_arithmetic_nan(&mut instance); + c1139_l1157_assert_return_canonical_nan(&mut instance); + c1140_l1158_assert_return_arithmetic_nan(&mut instance); + c1141_l1159_assert_return_canonical_nan(&mut instance); + c1142_l1160_assert_return_arithmetic_nan(&mut instance); + c1143_l1161_assert_return_canonical_nan(&mut instance); + c1144_l1162_assert_return_arithmetic_nan(&mut instance); + c1145_l1163_assert_return_canonical_nan(&mut instance); + c1146_l1164_assert_return_arithmetic_nan(&mut instance); + c1147_l1165_assert_return_canonical_nan(&mut instance); + c1148_l1166_assert_return_arithmetic_nan(&mut instance); + c1149_l1167_assert_return_canonical_nan(&mut instance); + c1150_l1168_assert_return_arithmetic_nan(&mut instance); + c1151_l1169_assert_return_canonical_nan(&mut instance); + c1152_l1170_assert_return_arithmetic_nan(&mut instance); + c1153_l1171_assert_return_canonical_nan(&mut instance); + c1154_l1172_assert_return_arithmetic_nan(&mut instance); + c1155_l1173_assert_return_canonical_nan(&mut instance); + c1156_l1174_assert_return_arithmetic_nan(&mut instance); + c1157_l1175_assert_return_canonical_nan(&mut instance); + c1158_l1176_assert_return_arithmetic_nan(&mut instance); + c1159_l1177_assert_return_canonical_nan(&mut instance); + c1160_l1178_assert_return_arithmetic_nan(&mut instance); + c1161_l1179_assert_return_canonical_nan(&mut instance); + c1162_l1180_assert_return_arithmetic_nan(&mut instance); + c1163_l1181_assert_return_canonical_nan(&mut instance); + c1164_l1182_assert_return_arithmetic_nan(&mut instance); + c1165_l1183_assert_return_canonical_nan(&mut instance); + c1166_l1184_assert_return_arithmetic_nan(&mut instance); + c1167_l1185_assert_return_canonical_nan(&mut instance); + c1168_l1186_assert_return_arithmetic_nan(&mut instance); + c1169_l1187_assert_return_canonical_nan(&mut instance); + c1170_l1188_assert_return_arithmetic_nan(&mut instance); + c1171_l1189_assert_return_canonical_nan(&mut instance); + c1172_l1190_assert_return_arithmetic_nan(&mut instance); + c1173_l1191_assert_return_canonical_nan(&mut instance); + c1174_l1192_assert_return_arithmetic_nan(&mut instance); + c1175_l1193_assert_return_canonical_nan(&mut instance); + c1176_l1194_assert_return_arithmetic_nan(&mut instance); + c1177_l1195_assert_return_canonical_nan(&mut instance); + c1178_l1196_assert_return_arithmetic_nan(&mut instance); + c1179_l1197_assert_return_canonical_nan(&mut instance); + c1180_l1198_assert_return_arithmetic_nan(&mut instance); + c1181_l1199_assert_return_canonical_nan(&mut instance); + c1182_l1200_assert_return_arithmetic_nan(&mut instance); + c1183_l1201_assert_return_canonical_nan(&mut instance); + c1184_l1202_assert_return_arithmetic_nan(&mut instance); + c1185_l1203_assert_return_canonical_nan(&mut instance); + c1186_l1204_assert_return_arithmetic_nan(&mut instance); + c1187_l1205_assert_return_arithmetic_nan(&mut instance); + c1188_l1206_assert_return_arithmetic_nan(&mut instance); + c1189_l1207_assert_return_canonical_nan(&mut instance); + c1190_l1208_assert_return_arithmetic_nan(&mut instance); + c1191_l1209_assert_return_arithmetic_nan(&mut instance); + c1192_l1210_assert_return_arithmetic_nan(&mut instance); + c1193_l1211_assert_return_canonical_nan(&mut instance); + c1194_l1212_assert_return_arithmetic_nan(&mut instance); + c1195_l1213_assert_return_arithmetic_nan(&mut instance); + c1196_l1214_assert_return_arithmetic_nan(&mut instance); + c1197_l1215_assert_return_canonical_nan(&mut instance); + c1198_l1216_assert_return_arithmetic_nan(&mut instance); + c1199_l1217_assert_return_arithmetic_nan(&mut instance); + c1200_l1218_assert_return_arithmetic_nan(&mut instance); + c1201_l1219_assert_return_canonical_nan(&mut instance); + c1202_l1220_assert_return_canonical_nan(&mut instance); + c1203_l1221_assert_return_canonical_nan(&mut instance); + c1204_l1222_assert_return_canonical_nan(&mut instance); + c1205_l1223_action_invoke(&mut instance); + c1206_l1224_action_invoke(&mut instance); + c1207_l1225_action_invoke(&mut instance); + c1208_l1226_action_invoke(&mut instance); + c1209_l1227_action_invoke(&mut instance); + c1210_l1228_action_invoke(&mut instance); + c1211_l1229_action_invoke(&mut instance); + c1212_l1230_action_invoke(&mut instance); + c1213_l1231_action_invoke(&mut instance); + c1214_l1232_action_invoke(&mut instance); + c1215_l1233_action_invoke(&mut instance); + c1216_l1234_action_invoke(&mut instance); + c1217_l1235_action_invoke(&mut instance); + c1218_l1236_action_invoke(&mut instance); + c1219_l1237_action_invoke(&mut instance); + c1220_l1238_action_invoke(&mut instance); + c1221_l1239_action_invoke(&mut instance); + c1222_l1240_action_invoke(&mut instance); + c1223_l1241_action_invoke(&mut instance); + c1224_l1242_action_invoke(&mut instance); + c1225_l1243_action_invoke(&mut instance); + c1226_l1244_action_invoke(&mut instance); + c1227_l1245_action_invoke(&mut instance); + c1228_l1246_action_invoke(&mut instance); + c1229_l1247_action_invoke(&mut instance); + c1230_l1248_action_invoke(&mut instance); + c1231_l1249_action_invoke(&mut instance); + c1232_l1250_action_invoke(&mut instance); + c1233_l1251_assert_return_canonical_nan(&mut instance); + c1234_l1252_assert_return_arithmetic_nan(&mut instance); + c1235_l1253_assert_return_canonical_nan(&mut instance); + c1236_l1254_assert_return_arithmetic_nan(&mut instance); + c1237_l1255_assert_return_canonical_nan(&mut instance); + c1238_l1256_assert_return_arithmetic_nan(&mut instance); + c1239_l1257_assert_return_canonical_nan(&mut instance); + c1240_l1258_assert_return_arithmetic_nan(&mut instance); + c1241_l1259_action_invoke(&mut instance); + c1242_l1260_action_invoke(&mut instance); + c1243_l1261_action_invoke(&mut instance); + c1244_l1262_action_invoke(&mut instance); + c1245_l1263_action_invoke(&mut instance); + c1246_l1264_action_invoke(&mut instance); + c1247_l1265_action_invoke(&mut instance); + c1248_l1266_action_invoke(&mut instance); + c1249_l1267_action_invoke(&mut instance); + c1250_l1268_action_invoke(&mut instance); + c1251_l1269_action_invoke(&mut instance); + c1252_l1270_action_invoke(&mut instance); + c1253_l1271_action_invoke(&mut instance); + c1254_l1272_action_invoke(&mut instance); + c1255_l1273_action_invoke(&mut instance); + c1256_l1274_action_invoke(&mut instance); + c1257_l1275_action_invoke(&mut instance); + c1258_l1276_action_invoke(&mut instance); + c1259_l1277_action_invoke(&mut instance); + c1260_l1278_action_invoke(&mut instance); + c1261_l1279_action_invoke(&mut instance); + c1262_l1280_action_invoke(&mut instance); + c1263_l1281_action_invoke(&mut instance); + c1264_l1282_action_invoke(&mut instance); + c1265_l1283_action_invoke(&mut instance); + c1266_l1284_action_invoke(&mut instance); + c1267_l1285_action_invoke(&mut instance); + c1268_l1286_action_invoke(&mut instance); + c1269_l1287_action_invoke(&mut instance); + c1270_l1288_action_invoke(&mut instance); + c1271_l1289_action_invoke(&mut instance); + c1272_l1290_action_invoke(&mut instance); + c1273_l1291_assert_return_canonical_nan(&mut instance); + c1274_l1292_assert_return_arithmetic_nan(&mut instance); + c1275_l1293_assert_return_canonical_nan(&mut instance); + c1276_l1294_assert_return_arithmetic_nan(&mut instance); + c1277_l1295_assert_return_canonical_nan(&mut instance); + c1278_l1296_assert_return_arithmetic_nan(&mut instance); + c1279_l1297_assert_return_canonical_nan(&mut instance); + c1280_l1298_assert_return_arithmetic_nan(&mut instance); + c1281_l1299_action_invoke(&mut instance); + c1282_l1300_action_invoke(&mut instance); + c1283_l1301_action_invoke(&mut instance); + c1284_l1302_action_invoke(&mut instance); + c1285_l1303_action_invoke(&mut instance); + c1286_l1304_action_invoke(&mut instance); + c1287_l1305_action_invoke(&mut instance); + c1288_l1306_action_invoke(&mut instance); + c1289_l1307_action_invoke(&mut instance); + c1290_l1308_action_invoke(&mut instance); + c1291_l1309_action_invoke(&mut instance); + c1292_l1310_action_invoke(&mut instance); + c1293_l1311_action_invoke(&mut instance); + c1294_l1312_action_invoke(&mut instance); + c1295_l1313_action_invoke(&mut instance); + c1296_l1314_action_invoke(&mut instance); + c1297_l1315_action_invoke(&mut instance); + c1298_l1316_action_invoke(&mut instance); + c1299_l1317_action_invoke(&mut instance); + c1300_l1318_action_invoke(&mut instance); + c1301_l1319_action_invoke(&mut instance); + c1302_l1320_action_invoke(&mut instance); + c1303_l1321_action_invoke(&mut instance); + c1304_l1322_action_invoke(&mut instance); + c1305_l1323_action_invoke(&mut instance); + c1306_l1324_action_invoke(&mut instance); + c1307_l1325_action_invoke(&mut instance); + c1308_l1326_action_invoke(&mut instance); + c1309_l1327_action_invoke(&mut instance); + c1310_l1328_action_invoke(&mut instance); + c1311_l1329_action_invoke(&mut instance); + c1312_l1330_action_invoke(&mut instance); + c1313_l1331_assert_return_canonical_nan(&mut instance); + c1314_l1332_assert_return_arithmetic_nan(&mut instance); + c1315_l1333_assert_return_canonical_nan(&mut instance); + c1316_l1334_assert_return_arithmetic_nan(&mut instance); + c1317_l1335_assert_return_canonical_nan(&mut instance); + c1318_l1336_assert_return_arithmetic_nan(&mut instance); + c1319_l1337_assert_return_canonical_nan(&mut instance); + c1320_l1338_assert_return_arithmetic_nan(&mut instance); + c1321_l1339_action_invoke(&mut instance); + c1322_l1340_action_invoke(&mut instance); + c1323_l1341_action_invoke(&mut instance); + c1324_l1342_action_invoke(&mut instance); + c1325_l1343_action_invoke(&mut instance); + c1326_l1344_action_invoke(&mut instance); + c1327_l1345_action_invoke(&mut instance); + c1328_l1346_action_invoke(&mut instance); + c1329_l1347_action_invoke(&mut instance); + c1330_l1348_action_invoke(&mut instance); + c1331_l1349_action_invoke(&mut instance); + c1332_l1350_action_invoke(&mut instance); + c1333_l1351_action_invoke(&mut instance); + c1334_l1352_action_invoke(&mut instance); + c1335_l1353_action_invoke(&mut instance); + c1336_l1354_action_invoke(&mut instance); + c1337_l1355_action_invoke(&mut instance); + c1338_l1356_action_invoke(&mut instance); + c1339_l1357_action_invoke(&mut instance); + c1340_l1358_action_invoke(&mut instance); + c1341_l1359_action_invoke(&mut instance); + c1342_l1360_action_invoke(&mut instance); + c1343_l1361_action_invoke(&mut instance); + c1344_l1362_action_invoke(&mut instance); + c1345_l1363_action_invoke(&mut instance); + c1346_l1364_action_invoke(&mut instance); + c1347_l1365_action_invoke(&mut instance); + c1348_l1366_action_invoke(&mut instance); + c1349_l1367_action_invoke(&mut instance); + c1350_l1368_action_invoke(&mut instance); + c1351_l1369_action_invoke(&mut instance); + c1352_l1370_action_invoke(&mut instance); + c1353_l1371_assert_return_canonical_nan(&mut instance); + c1354_l1372_assert_return_arithmetic_nan(&mut instance); + c1355_l1373_assert_return_canonical_nan(&mut instance); + c1356_l1374_assert_return_arithmetic_nan(&mut instance); + c1357_l1375_assert_return_canonical_nan(&mut instance); + c1358_l1376_assert_return_arithmetic_nan(&mut instance); + c1359_l1377_assert_return_canonical_nan(&mut instance); + c1360_l1378_assert_return_arithmetic_nan(&mut instance); + c1361_l1379_action_invoke(&mut instance); + c1362_l1380_action_invoke(&mut instance); + c1363_l1381_action_invoke(&mut instance); + c1364_l1382_action_invoke(&mut instance); + c1365_l1383_action_invoke(&mut instance); + c1366_l1384_action_invoke(&mut instance); + c1367_l1385_action_invoke(&mut instance); + c1368_l1386_action_invoke(&mut instance); + c1369_l1387_action_invoke(&mut instance); + c1370_l1388_action_invoke(&mut instance); + c1371_l1389_action_invoke(&mut instance); + c1372_l1390_action_invoke(&mut instance); + c1373_l1391_action_invoke(&mut instance); + c1374_l1392_action_invoke(&mut instance); + c1375_l1393_action_invoke(&mut instance); + c1376_l1394_action_invoke(&mut instance); + c1377_l1395_action_invoke(&mut instance); + c1378_l1396_action_invoke(&mut instance); + c1379_l1397_action_invoke(&mut instance); + c1380_l1398_action_invoke(&mut instance); + c1381_l1399_action_invoke(&mut instance); + c1382_l1400_action_invoke(&mut instance); + c1383_l1401_action_invoke(&mut instance); + c1384_l1402_action_invoke(&mut instance); + c1385_l1403_action_invoke(&mut instance); + c1386_l1404_action_invoke(&mut instance); + c1387_l1405_action_invoke(&mut instance); + c1388_l1406_action_invoke(&mut instance); + c1389_l1407_action_invoke(&mut instance); + c1390_l1408_action_invoke(&mut instance); + c1391_l1409_action_invoke(&mut instance); + c1392_l1410_action_invoke(&mut instance); + c1393_l1411_assert_return_canonical_nan(&mut instance); + c1394_l1412_assert_return_arithmetic_nan(&mut instance); + c1395_l1413_assert_return_canonical_nan(&mut instance); + c1396_l1414_assert_return_arithmetic_nan(&mut instance); + c1397_l1415_assert_return_canonical_nan(&mut instance); + c1398_l1416_assert_return_arithmetic_nan(&mut instance); + c1399_l1417_assert_return_canonical_nan(&mut instance); + c1400_l1418_assert_return_arithmetic_nan(&mut instance); + c1401_l1419_action_invoke(&mut instance); + c1402_l1420_action_invoke(&mut instance); + c1403_l1421_action_invoke(&mut instance); + c1404_l1422_action_invoke(&mut instance); + c1405_l1423_action_invoke(&mut instance); + c1406_l1424_action_invoke(&mut instance); + c1407_l1425_action_invoke(&mut instance); + c1408_l1426_action_invoke(&mut instance); + c1409_l1427_action_invoke(&mut instance); + c1410_l1428_action_invoke(&mut instance); + c1411_l1429_action_invoke(&mut instance); + c1412_l1430_action_invoke(&mut instance); + c1413_l1431_action_invoke(&mut instance); + c1414_l1432_action_invoke(&mut instance); + c1415_l1433_action_invoke(&mut instance); + c1416_l1434_action_invoke(&mut instance); + c1417_l1435_action_invoke(&mut instance); + c1418_l1436_action_invoke(&mut instance); + c1419_l1437_action_invoke(&mut instance); + c1420_l1438_action_invoke(&mut instance); + c1421_l1439_action_invoke(&mut instance); + c1422_l1440_action_invoke(&mut instance); + c1423_l1441_action_invoke(&mut instance); + c1424_l1442_action_invoke(&mut instance); + c1425_l1443_action_invoke(&mut instance); + c1426_l1444_action_invoke(&mut instance); + c1427_l1445_action_invoke(&mut instance); + c1428_l1446_action_invoke(&mut instance); + c1429_l1447_action_invoke(&mut instance); + c1430_l1448_action_invoke(&mut instance); + c1431_l1449_action_invoke(&mut instance); + c1432_l1450_action_invoke(&mut instance); + c1433_l1451_assert_return_canonical_nan(&mut instance); + c1434_l1452_assert_return_arithmetic_nan(&mut instance); + c1435_l1453_assert_return_canonical_nan(&mut instance); + c1436_l1454_assert_return_arithmetic_nan(&mut instance); + c1437_l1455_assert_return_canonical_nan(&mut instance); + c1438_l1456_assert_return_arithmetic_nan(&mut instance); + c1439_l1457_assert_return_canonical_nan(&mut instance); + c1440_l1458_assert_return_arithmetic_nan(&mut instance); + c1441_l1459_action_invoke(&mut instance); + c1442_l1460_action_invoke(&mut instance); + c1443_l1461_action_invoke(&mut instance); + c1444_l1462_action_invoke(&mut instance); + c1445_l1463_action_invoke(&mut instance); + c1446_l1464_action_invoke(&mut instance); + c1447_l1465_action_invoke(&mut instance); + c1448_l1466_action_invoke(&mut instance); + c1449_l1467_action_invoke(&mut instance); + c1450_l1468_action_invoke(&mut instance); + c1451_l1469_action_invoke(&mut instance); + c1452_l1470_action_invoke(&mut instance); + c1453_l1471_action_invoke(&mut instance); + c1454_l1472_action_invoke(&mut instance); + c1455_l1473_action_invoke(&mut instance); + c1456_l1474_action_invoke(&mut instance); + c1457_l1475_action_invoke(&mut instance); + c1458_l1476_action_invoke(&mut instance); + c1459_l1477_action_invoke(&mut instance); + c1460_l1478_action_invoke(&mut instance); + c1461_l1479_action_invoke(&mut instance); + c1462_l1480_action_invoke(&mut instance); + c1463_l1481_action_invoke(&mut instance); + c1464_l1482_action_invoke(&mut instance); + c1465_l1483_action_invoke(&mut instance); + c1466_l1484_action_invoke(&mut instance); + c1467_l1485_action_invoke(&mut instance); + c1468_l1486_action_invoke(&mut instance); + c1469_l1487_action_invoke(&mut instance); + c1470_l1488_action_invoke(&mut instance); + c1471_l1489_action_invoke(&mut instance); + c1472_l1490_action_invoke(&mut instance); + c1473_l1491_assert_return_canonical_nan(&mut instance); + c1474_l1492_assert_return_arithmetic_nan(&mut instance); + c1475_l1493_assert_return_canonical_nan(&mut instance); + c1476_l1494_assert_return_arithmetic_nan(&mut instance); + c1477_l1495_assert_return_canonical_nan(&mut instance); + c1478_l1496_assert_return_arithmetic_nan(&mut instance); + c1479_l1497_assert_return_canonical_nan(&mut instance); + c1480_l1498_assert_return_arithmetic_nan(&mut instance); + c1481_l1499_action_invoke(&mut instance); + c1482_l1500_action_invoke(&mut instance); + c1483_l1501_action_invoke(&mut instance); + c1484_l1502_action_invoke(&mut instance); + c1485_l1503_action_invoke(&mut instance); + c1486_l1504_action_invoke(&mut instance); + c1487_l1505_action_invoke(&mut instance); + c1488_l1506_action_invoke(&mut instance); + c1489_l1507_action_invoke(&mut instance); + c1490_l1508_action_invoke(&mut instance); + c1491_l1509_action_invoke(&mut instance); + c1492_l1510_action_invoke(&mut instance); + c1493_l1511_action_invoke(&mut instance); + c1494_l1512_action_invoke(&mut instance); + c1495_l1513_action_invoke(&mut instance); + c1496_l1514_action_invoke(&mut instance); + c1497_l1515_action_invoke(&mut instance); + c1498_l1516_action_invoke(&mut instance); + c1499_l1517_action_invoke(&mut instance); + c1500_l1518_action_invoke(&mut instance); + c1501_l1519_action_invoke(&mut instance); + c1502_l1520_action_invoke(&mut instance); + c1503_l1521_action_invoke(&mut instance); + c1504_l1522_action_invoke(&mut instance); + c1505_l1523_action_invoke(&mut instance); + c1506_l1524_action_invoke(&mut instance); + c1507_l1525_action_invoke(&mut instance); + c1508_l1526_action_invoke(&mut instance); + c1509_l1527_assert_return_canonical_nan(&mut instance); + c1510_l1528_assert_return_canonical_nan(&mut instance); + c1511_l1529_assert_return_canonical_nan(&mut instance); + c1512_l1530_assert_return_canonical_nan(&mut instance); + c1513_l1531_assert_return_canonical_nan(&mut instance); + c1514_l1532_assert_return_arithmetic_nan(&mut instance); + c1515_l1533_assert_return_canonical_nan(&mut instance); + c1516_l1534_assert_return_arithmetic_nan(&mut instance); + c1517_l1535_assert_return_canonical_nan(&mut instance); + c1518_l1536_assert_return_arithmetic_nan(&mut instance); + c1519_l1537_assert_return_canonical_nan(&mut instance); + c1520_l1538_assert_return_arithmetic_nan(&mut instance); + c1521_l1539_assert_return_canonical_nan(&mut instance); + c1522_l1540_assert_return_arithmetic_nan(&mut instance); + c1523_l1541_assert_return_canonical_nan(&mut instance); + c1524_l1542_assert_return_arithmetic_nan(&mut instance); + c1525_l1543_assert_return_canonical_nan(&mut instance); + c1526_l1544_assert_return_arithmetic_nan(&mut instance); + c1527_l1545_assert_return_canonical_nan(&mut instance); + c1528_l1546_assert_return_arithmetic_nan(&mut instance); + c1529_l1547_assert_return_canonical_nan(&mut instance); + c1530_l1548_assert_return_arithmetic_nan(&mut instance); + c1531_l1549_assert_return_canonical_nan(&mut instance); + c1532_l1550_assert_return_arithmetic_nan(&mut instance); + c1533_l1551_assert_return_canonical_nan(&mut instance); + c1534_l1552_assert_return_arithmetic_nan(&mut instance); + c1535_l1553_assert_return_canonical_nan(&mut instance); + c1536_l1554_assert_return_arithmetic_nan(&mut instance); + c1537_l1555_assert_return_canonical_nan(&mut instance); + c1538_l1556_assert_return_arithmetic_nan(&mut instance); + c1539_l1557_assert_return_canonical_nan(&mut instance); + c1540_l1558_assert_return_arithmetic_nan(&mut instance); + c1541_l1559_assert_return_canonical_nan(&mut instance); + c1542_l1560_assert_return_arithmetic_nan(&mut instance); + c1543_l1561_assert_return_canonical_nan(&mut instance); + c1544_l1562_assert_return_arithmetic_nan(&mut instance); + c1545_l1563_assert_return_canonical_nan(&mut instance); + c1546_l1564_assert_return_arithmetic_nan(&mut instance); + c1547_l1565_assert_return_canonical_nan(&mut instance); + c1548_l1566_assert_return_arithmetic_nan(&mut instance); + c1549_l1567_assert_return_canonical_nan(&mut instance); + c1550_l1568_assert_return_arithmetic_nan(&mut instance); + c1551_l1569_assert_return_canonical_nan(&mut instance); + c1552_l1570_assert_return_arithmetic_nan(&mut instance); + c1553_l1571_assert_return_canonical_nan(&mut instance); + c1554_l1572_assert_return_arithmetic_nan(&mut instance); + c1555_l1573_assert_return_canonical_nan(&mut instance); + c1556_l1574_assert_return_arithmetic_nan(&mut instance); + c1557_l1575_assert_return_canonical_nan(&mut instance); + c1558_l1576_assert_return_arithmetic_nan(&mut instance); + c1559_l1577_assert_return_canonical_nan(&mut instance); + c1560_l1578_assert_return_arithmetic_nan(&mut instance); + c1561_l1579_assert_return_canonical_nan(&mut instance); + c1562_l1580_assert_return_arithmetic_nan(&mut instance); + c1563_l1581_assert_return_canonical_nan(&mut instance); + c1564_l1582_assert_return_arithmetic_nan(&mut instance); + c1565_l1583_assert_return_canonical_nan(&mut instance); + c1566_l1584_assert_return_arithmetic_nan(&mut instance); + c1567_l1585_assert_return_canonical_nan(&mut instance); + c1568_l1586_assert_return_arithmetic_nan(&mut instance); + c1569_l1587_assert_return_canonical_nan(&mut instance); + c1570_l1588_assert_return_arithmetic_nan(&mut instance); + c1571_l1589_assert_return_canonical_nan(&mut instance); + c1572_l1590_assert_return_arithmetic_nan(&mut instance); + c1573_l1591_assert_return_canonical_nan(&mut instance); + c1574_l1592_assert_return_arithmetic_nan(&mut instance); + c1575_l1593_assert_return_canonical_nan(&mut instance); + c1576_l1594_assert_return_arithmetic_nan(&mut instance); + c1577_l1595_assert_return_canonical_nan(&mut instance); + c1578_l1596_assert_return_arithmetic_nan(&mut instance); + c1579_l1597_assert_return_canonical_nan(&mut instance); + c1580_l1598_assert_return_arithmetic_nan(&mut instance); + c1581_l1599_assert_return_canonical_nan(&mut instance); + c1582_l1600_assert_return_arithmetic_nan(&mut instance); + c1583_l1601_assert_return_canonical_nan(&mut instance); + c1584_l1602_assert_return_arithmetic_nan(&mut instance); + c1585_l1603_assert_return_canonical_nan(&mut instance); + c1586_l1604_assert_return_arithmetic_nan(&mut instance); + c1587_l1605_assert_return_arithmetic_nan(&mut instance); + c1588_l1606_assert_return_arithmetic_nan(&mut instance); + c1589_l1607_assert_return_canonical_nan(&mut instance); + c1590_l1608_assert_return_arithmetic_nan(&mut instance); + c1591_l1609_assert_return_arithmetic_nan(&mut instance); + c1592_l1610_assert_return_arithmetic_nan(&mut instance); + c1593_l1611_assert_return_canonical_nan(&mut instance); + c1594_l1612_assert_return_arithmetic_nan(&mut instance); + c1595_l1613_assert_return_arithmetic_nan(&mut instance); + c1596_l1614_assert_return_arithmetic_nan(&mut instance); + c1597_l1615_assert_return_canonical_nan(&mut instance); + c1598_l1616_assert_return_arithmetic_nan(&mut instance); + c1599_l1617_assert_return_arithmetic_nan(&mut instance); + c1600_l1618_assert_return_arithmetic_nan(&mut instance); + c1601_l1619_action_invoke(&mut instance); + c1602_l1620_action_invoke(&mut instance); + c1603_l1621_action_invoke(&mut instance); + c1604_l1622_action_invoke(&mut instance); + c1605_l1623_action_invoke(&mut instance); + c1606_l1624_action_invoke(&mut instance); + c1607_l1625_action_invoke(&mut instance); + c1608_l1626_action_invoke(&mut instance); + c1609_l1627_action_invoke(&mut instance); + c1610_l1628_action_invoke(&mut instance); + c1611_l1629_action_invoke(&mut instance); + c1612_l1630_action_invoke(&mut instance); + c1613_l1631_action_invoke(&mut instance); + c1614_l1632_action_invoke(&mut instance); + c1615_l1633_action_invoke(&mut instance); + c1616_l1634_action_invoke(&mut instance); + c1617_l1635_action_invoke(&mut instance); + c1618_l1636_action_invoke(&mut instance); + c1619_l1637_action_invoke(&mut instance); + c1620_l1638_action_invoke(&mut instance); + c1621_l1639_action_invoke(&mut instance); + c1622_l1640_action_invoke(&mut instance); + c1623_l1641_action_invoke(&mut instance); + c1624_l1642_action_invoke(&mut instance); + c1625_l1643_action_invoke(&mut instance); + c1626_l1644_action_invoke(&mut instance); + c1627_l1645_action_invoke(&mut instance); + c1628_l1646_action_invoke(&mut instance); + c1629_l1647_action_invoke(&mut instance); + c1630_l1648_action_invoke(&mut instance); + c1631_l1649_action_invoke(&mut instance); + c1632_l1650_action_invoke(&mut instance); + c1633_l1651_assert_return_canonical_nan(&mut instance); + c1634_l1652_assert_return_arithmetic_nan(&mut instance); + c1635_l1653_assert_return_canonical_nan(&mut instance); + c1636_l1654_assert_return_arithmetic_nan(&mut instance); + c1637_l1655_assert_return_canonical_nan(&mut instance); + c1638_l1656_assert_return_arithmetic_nan(&mut instance); + c1639_l1657_assert_return_canonical_nan(&mut instance); + c1640_l1658_assert_return_arithmetic_nan(&mut instance); + c1641_l1659_action_invoke(&mut instance); + c1642_l1660_action_invoke(&mut instance); + c1643_l1661_action_invoke(&mut instance); + c1644_l1662_action_invoke(&mut instance); + c1645_l1663_action_invoke(&mut instance); + c1646_l1664_action_invoke(&mut instance); + c1647_l1665_action_invoke(&mut instance); + c1648_l1666_action_invoke(&mut instance); + c1649_l1667_action_invoke(&mut instance); + c1650_l1668_action_invoke(&mut instance); + c1651_l1669_action_invoke(&mut instance); + c1652_l1670_action_invoke(&mut instance); + c1653_l1671_action_invoke(&mut instance); + c1654_l1672_action_invoke(&mut instance); + c1655_l1673_action_invoke(&mut instance); + c1656_l1674_action_invoke(&mut instance); + c1657_l1675_action_invoke(&mut instance); + c1658_l1676_action_invoke(&mut instance); + c1659_l1677_action_invoke(&mut instance); + c1660_l1678_action_invoke(&mut instance); + c1661_l1679_action_invoke(&mut instance); + c1662_l1680_action_invoke(&mut instance); + c1663_l1681_action_invoke(&mut instance); + c1664_l1682_action_invoke(&mut instance); + c1665_l1683_action_invoke(&mut instance); + c1666_l1684_action_invoke(&mut instance); + c1667_l1685_action_invoke(&mut instance); + c1668_l1686_action_invoke(&mut instance); + c1669_l1687_action_invoke(&mut instance); + c1670_l1688_action_invoke(&mut instance); + c1671_l1689_action_invoke(&mut instance); + c1672_l1690_action_invoke(&mut instance); + c1673_l1691_assert_return_canonical_nan(&mut instance); + c1674_l1692_assert_return_arithmetic_nan(&mut instance); + c1675_l1693_assert_return_canonical_nan(&mut instance); + c1676_l1694_assert_return_arithmetic_nan(&mut instance); + c1677_l1695_assert_return_canonical_nan(&mut instance); + c1678_l1696_assert_return_arithmetic_nan(&mut instance); + c1679_l1697_assert_return_canonical_nan(&mut instance); + c1680_l1698_assert_return_arithmetic_nan(&mut instance); + c1681_l1699_action_invoke(&mut instance); + c1682_l1700_action_invoke(&mut instance); + c1683_l1701_action_invoke(&mut instance); + c1684_l1702_action_invoke(&mut instance); + c1685_l1703_action_invoke(&mut instance); + c1686_l1704_action_invoke(&mut instance); + c1687_l1705_action_invoke(&mut instance); + c1688_l1706_action_invoke(&mut instance); + c1689_l1707_action_invoke(&mut instance); + c1690_l1708_action_invoke(&mut instance); + c1691_l1709_action_invoke(&mut instance); + c1692_l1710_action_invoke(&mut instance); + c1693_l1711_action_invoke(&mut instance); + c1694_l1712_action_invoke(&mut instance); + c1695_l1713_action_invoke(&mut instance); + c1696_l1714_action_invoke(&mut instance); + c1697_l1715_action_invoke(&mut instance); + c1698_l1716_action_invoke(&mut instance); + c1699_l1717_action_invoke(&mut instance); + c1700_l1718_action_invoke(&mut instance); + c1701_l1719_action_invoke(&mut instance); + c1702_l1720_action_invoke(&mut instance); + c1703_l1721_action_invoke(&mut instance); + c1704_l1722_action_invoke(&mut instance); + c1705_l1723_action_invoke(&mut instance); + c1706_l1724_action_invoke(&mut instance); + c1707_l1725_action_invoke(&mut instance); + c1708_l1726_action_invoke(&mut instance); + c1709_l1727_action_invoke(&mut instance); + c1710_l1728_action_invoke(&mut instance); + c1711_l1729_action_invoke(&mut instance); + c1712_l1730_action_invoke(&mut instance); + c1713_l1731_assert_return_canonical_nan(&mut instance); + c1714_l1732_assert_return_arithmetic_nan(&mut instance); + c1715_l1733_assert_return_canonical_nan(&mut instance); + c1716_l1734_assert_return_arithmetic_nan(&mut instance); + c1717_l1735_assert_return_canonical_nan(&mut instance); + c1718_l1736_assert_return_arithmetic_nan(&mut instance); + c1719_l1737_assert_return_canonical_nan(&mut instance); + c1720_l1738_assert_return_arithmetic_nan(&mut instance); + c1721_l1739_action_invoke(&mut instance); + c1722_l1740_action_invoke(&mut instance); + c1723_l1741_action_invoke(&mut instance); + c1724_l1742_action_invoke(&mut instance); + c1725_l1743_action_invoke(&mut instance); + c1726_l1744_action_invoke(&mut instance); + c1727_l1745_action_invoke(&mut instance); + c1728_l1746_action_invoke(&mut instance); + c1729_l1747_action_invoke(&mut instance); + c1730_l1748_action_invoke(&mut instance); + c1731_l1749_action_invoke(&mut instance); + c1732_l1750_action_invoke(&mut instance); + c1733_l1751_action_invoke(&mut instance); + c1734_l1752_action_invoke(&mut instance); + c1735_l1753_action_invoke(&mut instance); + c1736_l1754_action_invoke(&mut instance); + c1737_l1755_action_invoke(&mut instance); + c1738_l1756_action_invoke(&mut instance); + c1739_l1757_action_invoke(&mut instance); + c1740_l1758_action_invoke(&mut instance); + c1741_l1759_action_invoke(&mut instance); + c1742_l1760_action_invoke(&mut instance); + c1743_l1761_action_invoke(&mut instance); + c1744_l1762_action_invoke(&mut instance); + c1745_l1763_action_invoke(&mut instance); + c1746_l1764_action_invoke(&mut instance); + c1747_l1765_action_invoke(&mut instance); + c1748_l1766_action_invoke(&mut instance); + c1749_l1767_action_invoke(&mut instance); + c1750_l1768_action_invoke(&mut instance); + c1751_l1769_action_invoke(&mut instance); + c1752_l1770_action_invoke(&mut instance); + c1753_l1771_assert_return_canonical_nan(&mut instance); + c1754_l1772_assert_return_arithmetic_nan(&mut instance); + c1755_l1773_assert_return_canonical_nan(&mut instance); + c1756_l1774_assert_return_arithmetic_nan(&mut instance); + c1757_l1775_assert_return_canonical_nan(&mut instance); + c1758_l1776_assert_return_arithmetic_nan(&mut instance); + c1759_l1777_assert_return_canonical_nan(&mut instance); + c1760_l1778_assert_return_arithmetic_nan(&mut instance); + c1761_l1779_action_invoke(&mut instance); + c1762_l1780_action_invoke(&mut instance); + c1763_l1781_action_invoke(&mut instance); + c1764_l1782_action_invoke(&mut instance); + c1765_l1783_action_invoke(&mut instance); + c1766_l1784_action_invoke(&mut instance); + c1767_l1785_action_invoke(&mut instance); + c1768_l1786_action_invoke(&mut instance); + c1769_l1787_action_invoke(&mut instance); + c1770_l1788_action_invoke(&mut instance); + c1771_l1789_action_invoke(&mut instance); + c1772_l1790_action_invoke(&mut instance); + c1773_l1791_action_invoke(&mut instance); + c1774_l1792_action_invoke(&mut instance); + c1775_l1793_action_invoke(&mut instance); + c1776_l1794_action_invoke(&mut instance); + c1777_l1795_action_invoke(&mut instance); + c1778_l1796_action_invoke(&mut instance); + c1779_l1797_action_invoke(&mut instance); + c1780_l1798_action_invoke(&mut instance); + c1781_l1799_action_invoke(&mut instance); + c1782_l1800_action_invoke(&mut instance); + c1783_l1801_action_invoke(&mut instance); + c1784_l1802_action_invoke(&mut instance); + c1785_l1803_action_invoke(&mut instance); + c1786_l1804_action_invoke(&mut instance); + c1787_l1805_action_invoke(&mut instance); + c1788_l1806_action_invoke(&mut instance); + c1789_l1807_action_invoke(&mut instance); + c1790_l1808_action_invoke(&mut instance); + c1791_l1809_action_invoke(&mut instance); + c1792_l1810_action_invoke(&mut instance); + c1793_l1811_assert_return_canonical_nan(&mut instance); + c1794_l1812_assert_return_arithmetic_nan(&mut instance); + c1795_l1813_assert_return_canonical_nan(&mut instance); + c1796_l1814_assert_return_arithmetic_nan(&mut instance); + c1797_l1815_assert_return_canonical_nan(&mut instance); + c1798_l1816_assert_return_arithmetic_nan(&mut instance); + c1799_l1817_assert_return_canonical_nan(&mut instance); + c1800_l1818_assert_return_arithmetic_nan(&mut instance); + c1801_l1819_action_invoke(&mut instance); + c1802_l1820_action_invoke(&mut instance); + c1803_l1821_action_invoke(&mut instance); + c1804_l1822_action_invoke(&mut instance); + c1805_l1823_action_invoke(&mut instance); + c1806_l1824_action_invoke(&mut instance); + c1807_l1825_action_invoke(&mut instance); + c1808_l1826_action_invoke(&mut instance); + c1809_l1827_action_invoke(&mut instance); + c1810_l1828_action_invoke(&mut instance); + c1811_l1829_action_invoke(&mut instance); + c1812_l1830_action_invoke(&mut instance); + c1813_l1831_action_invoke(&mut instance); + c1814_l1832_action_invoke(&mut instance); + c1815_l1833_action_invoke(&mut instance); + c1816_l1834_action_invoke(&mut instance); + c1817_l1835_action_invoke(&mut instance); + c1818_l1836_action_invoke(&mut instance); + c1819_l1837_action_invoke(&mut instance); + c1820_l1838_action_invoke(&mut instance); + c1821_l1839_action_invoke(&mut instance); + c1822_l1840_action_invoke(&mut instance); + c1823_l1841_action_invoke(&mut instance); + c1824_l1842_action_invoke(&mut instance); + c1825_l1843_action_invoke(&mut instance); + c1826_l1844_action_invoke(&mut instance); + c1827_l1845_action_invoke(&mut instance); + c1828_l1846_action_invoke(&mut instance); + c1829_l1847_action_invoke(&mut instance); + c1830_l1848_action_invoke(&mut instance); + c1831_l1849_action_invoke(&mut instance); + c1832_l1850_action_invoke(&mut instance); + c1833_l1851_assert_return_canonical_nan(&mut instance); + c1834_l1852_assert_return_arithmetic_nan(&mut instance); + c1835_l1853_assert_return_canonical_nan(&mut instance); + c1836_l1854_assert_return_arithmetic_nan(&mut instance); + c1837_l1855_assert_return_canonical_nan(&mut instance); + c1838_l1856_assert_return_arithmetic_nan(&mut instance); + c1839_l1857_assert_return_canonical_nan(&mut instance); + c1840_l1858_assert_return_arithmetic_nan(&mut instance); + c1841_l1859_action_invoke(&mut instance); + c1842_l1860_action_invoke(&mut instance); + c1843_l1861_action_invoke(&mut instance); + c1844_l1862_action_invoke(&mut instance); + c1845_l1863_action_invoke(&mut instance); + c1846_l1864_action_invoke(&mut instance); + c1847_l1865_action_invoke(&mut instance); + c1848_l1866_action_invoke(&mut instance); + c1849_l1867_action_invoke(&mut instance); + c1850_l1868_action_invoke(&mut instance); + c1851_l1869_action_invoke(&mut instance); + c1852_l1870_action_invoke(&mut instance); + c1853_l1871_action_invoke(&mut instance); + c1854_l1872_action_invoke(&mut instance); + c1855_l1873_action_invoke(&mut instance); + c1856_l1874_action_invoke(&mut instance); + c1857_l1875_action_invoke(&mut instance); + c1858_l1876_action_invoke(&mut instance); + c1859_l1877_action_invoke(&mut instance); + c1860_l1878_action_invoke(&mut instance); + c1861_l1879_action_invoke(&mut instance); + c1862_l1880_action_invoke(&mut instance); + c1863_l1881_action_invoke(&mut instance); + c1864_l1882_action_invoke(&mut instance); + c1865_l1883_action_invoke(&mut instance); + c1866_l1884_action_invoke(&mut instance); + c1867_l1885_action_invoke(&mut instance); + c1868_l1886_action_invoke(&mut instance); + c1869_l1887_action_invoke(&mut instance); + c1870_l1888_action_invoke(&mut instance); + c1871_l1889_action_invoke(&mut instance); + c1872_l1890_action_invoke(&mut instance); + c1873_l1891_assert_return_canonical_nan(&mut instance); + c1874_l1892_assert_return_arithmetic_nan(&mut instance); + c1875_l1893_assert_return_canonical_nan(&mut instance); + c1876_l1894_assert_return_arithmetic_nan(&mut instance); + c1877_l1895_assert_return_canonical_nan(&mut instance); + c1878_l1896_assert_return_arithmetic_nan(&mut instance); + c1879_l1897_assert_return_canonical_nan(&mut instance); + c1880_l1898_assert_return_arithmetic_nan(&mut instance); + c1881_l1899_action_invoke(&mut instance); + c1882_l1900_action_invoke(&mut instance); + c1883_l1901_action_invoke(&mut instance); + c1884_l1902_action_invoke(&mut instance); + c1885_l1903_action_invoke(&mut instance); + c1886_l1904_action_invoke(&mut instance); + c1887_l1905_action_invoke(&mut instance); + c1888_l1906_action_invoke(&mut instance); + c1889_l1907_action_invoke(&mut instance); + c1890_l1908_action_invoke(&mut instance); + c1891_l1909_action_invoke(&mut instance); + c1892_l1910_action_invoke(&mut instance); + c1893_l1911_action_invoke(&mut instance); + c1894_l1912_action_invoke(&mut instance); + c1895_l1913_action_invoke(&mut instance); + c1896_l1914_action_invoke(&mut instance); + c1897_l1915_action_invoke(&mut instance); + c1898_l1916_action_invoke(&mut instance); + c1899_l1917_action_invoke(&mut instance); + c1900_l1918_action_invoke(&mut instance); + c1901_l1919_action_invoke(&mut instance); + c1902_l1920_action_invoke(&mut instance); + c1903_l1921_action_invoke(&mut instance); + c1904_l1922_action_invoke(&mut instance); + c1905_l1923_action_invoke(&mut instance); + c1906_l1924_action_invoke(&mut instance); + c1907_l1925_action_invoke(&mut instance); + c1908_l1926_action_invoke(&mut instance); + c1909_l1927_action_invoke(&mut instance); + c1910_l1928_action_invoke(&mut instance); + c1911_l1929_action_invoke(&mut instance); + c1912_l1930_action_invoke(&mut instance); + c1913_l1931_assert_return_canonical_nan(&mut instance); + c1914_l1932_assert_return_arithmetic_nan(&mut instance); + c1915_l1933_assert_return_canonical_nan(&mut instance); + c1916_l1934_assert_return_arithmetic_nan(&mut instance); + c1917_l1935_assert_return_canonical_nan(&mut instance); + c1918_l1936_assert_return_arithmetic_nan(&mut instance); + c1919_l1937_assert_return_canonical_nan(&mut instance); + c1920_l1938_assert_return_arithmetic_nan(&mut instance); + c1921_l1939_assert_return_canonical_nan(&mut instance); + c1922_l1940_assert_return_arithmetic_nan(&mut instance); + c1923_l1941_assert_return_canonical_nan(&mut instance); + c1924_l1942_assert_return_arithmetic_nan(&mut instance); + c1925_l1943_assert_return_canonical_nan(&mut instance); + c1926_l1944_assert_return_arithmetic_nan(&mut instance); + c1927_l1945_assert_return_canonical_nan(&mut instance); + c1928_l1946_assert_return_arithmetic_nan(&mut instance); + c1929_l1947_assert_return_canonical_nan(&mut instance); + c1930_l1948_assert_return_arithmetic_nan(&mut instance); + c1931_l1949_assert_return_canonical_nan(&mut instance); + c1932_l1950_assert_return_arithmetic_nan(&mut instance); + c1933_l1951_assert_return_canonical_nan(&mut instance); + c1934_l1952_assert_return_arithmetic_nan(&mut instance); + c1935_l1953_assert_return_canonical_nan(&mut instance); + c1936_l1954_assert_return_arithmetic_nan(&mut instance); + c1937_l1955_assert_return_canonical_nan(&mut instance); + c1938_l1956_assert_return_arithmetic_nan(&mut instance); + c1939_l1957_assert_return_canonical_nan(&mut instance); + c1940_l1958_assert_return_arithmetic_nan(&mut instance); + c1941_l1959_assert_return_canonical_nan(&mut instance); + c1942_l1960_assert_return_arithmetic_nan(&mut instance); + c1943_l1961_assert_return_canonical_nan(&mut instance); + c1944_l1962_assert_return_arithmetic_nan(&mut instance); + c1945_l1963_assert_return_canonical_nan(&mut instance); + c1946_l1964_assert_return_arithmetic_nan(&mut instance); + c1947_l1965_assert_return_canonical_nan(&mut instance); + c1948_l1966_assert_return_arithmetic_nan(&mut instance); + c1949_l1967_assert_return_canonical_nan(&mut instance); + c1950_l1968_assert_return_arithmetic_nan(&mut instance); + c1951_l1969_assert_return_canonical_nan(&mut instance); + c1952_l1970_assert_return_arithmetic_nan(&mut instance); + c1953_l1971_assert_return_canonical_nan(&mut instance); + c1954_l1972_assert_return_arithmetic_nan(&mut instance); + c1955_l1973_assert_return_canonical_nan(&mut instance); + c1956_l1974_assert_return_arithmetic_nan(&mut instance); + c1957_l1975_assert_return_canonical_nan(&mut instance); + c1958_l1976_assert_return_arithmetic_nan(&mut instance); + c1959_l1977_assert_return_canonical_nan(&mut instance); + c1960_l1978_assert_return_arithmetic_nan(&mut instance); + c1961_l1979_assert_return_canonical_nan(&mut instance); + c1962_l1980_assert_return_arithmetic_nan(&mut instance); + c1963_l1981_assert_return_canonical_nan(&mut instance); + c1964_l1982_assert_return_arithmetic_nan(&mut instance); + c1965_l1983_assert_return_canonical_nan(&mut instance); + c1966_l1984_assert_return_arithmetic_nan(&mut instance); + c1967_l1985_assert_return_canonical_nan(&mut instance); + c1968_l1986_assert_return_arithmetic_nan(&mut instance); + c1969_l1987_assert_return_canonical_nan(&mut instance); + c1970_l1988_assert_return_arithmetic_nan(&mut instance); + c1971_l1989_assert_return_canonical_nan(&mut instance); + c1972_l1990_assert_return_arithmetic_nan(&mut instance); + c1973_l1991_assert_return_canonical_nan(&mut instance); + c1974_l1992_assert_return_arithmetic_nan(&mut instance); + c1975_l1993_assert_return_canonical_nan(&mut instance); + c1976_l1994_assert_return_arithmetic_nan(&mut instance); + c1977_l1995_assert_return_canonical_nan(&mut instance); + c1978_l1996_assert_return_arithmetic_nan(&mut instance); + c1979_l1997_assert_return_canonical_nan(&mut instance); + c1980_l1998_assert_return_arithmetic_nan(&mut instance); + c1981_l1999_assert_return_canonical_nan(&mut instance); + c1982_l2000_assert_return_arithmetic_nan(&mut instance); + c1983_l2001_assert_return_canonical_nan(&mut instance); + c1984_l2002_assert_return_arithmetic_nan(&mut instance); + c1985_l2003_assert_return_canonical_nan(&mut instance); + c1986_l2004_assert_return_arithmetic_nan(&mut instance); + c1987_l2005_assert_return_arithmetic_nan(&mut instance); + c1988_l2006_assert_return_arithmetic_nan(&mut instance); + c1989_l2007_assert_return_canonical_nan(&mut instance); + c1990_l2008_assert_return_arithmetic_nan(&mut instance); + c1991_l2009_assert_return_arithmetic_nan(&mut instance); + c1992_l2010_assert_return_arithmetic_nan(&mut instance); + c1993_l2011_assert_return_canonical_nan(&mut instance); + c1994_l2012_assert_return_arithmetic_nan(&mut instance); + c1995_l2013_assert_return_arithmetic_nan(&mut instance); + c1996_l2014_assert_return_arithmetic_nan(&mut instance); + c1997_l2015_assert_return_canonical_nan(&mut instance); + c1998_l2016_assert_return_arithmetic_nan(&mut instance); + c1999_l2017_assert_return_arithmetic_nan(&mut instance); + c2000_l2018_assert_return_arithmetic_nan(&mut instance); + c2001_l2019_action_invoke(&mut instance); + c2002_l2020_action_invoke(&mut instance); + c2003_l2021_action_invoke(&mut instance); + c2004_l2022_action_invoke(&mut instance); + c2005_l2023_action_invoke(&mut instance); + c2006_l2024_action_invoke(&mut instance); + c2007_l2025_action_invoke(&mut instance); + c2008_l2026_action_invoke(&mut instance); + c2009_l2027_action_invoke(&mut instance); + c2010_l2028_action_invoke(&mut instance); + c2011_l2029_action_invoke(&mut instance); + c2012_l2030_action_invoke(&mut instance); + c2013_l2031_action_invoke(&mut instance); + c2014_l2032_action_invoke(&mut instance); + c2015_l2033_action_invoke(&mut instance); + c2016_l2034_action_invoke(&mut instance); + c2017_l2035_action_invoke(&mut instance); + c2018_l2036_action_invoke(&mut instance); + c2019_l2037_action_invoke(&mut instance); + c2020_l2038_action_invoke(&mut instance); + c2021_l2039_action_invoke(&mut instance); + c2022_l2040_action_invoke(&mut instance); + c2023_l2041_action_invoke(&mut instance); + c2024_l2042_action_invoke(&mut instance); + c2025_l2043_action_invoke(&mut instance); + c2026_l2044_action_invoke(&mut instance); + c2027_l2045_action_invoke(&mut instance); + c2028_l2046_action_invoke(&mut instance); + c2029_l2047_action_invoke(&mut instance); + c2030_l2048_action_invoke(&mut instance); + c2031_l2049_action_invoke(&mut instance); + c2032_l2050_action_invoke(&mut instance); + c2033_l2051_assert_return_canonical_nan(&mut instance); + c2034_l2052_assert_return_arithmetic_nan(&mut instance); + c2035_l2053_assert_return_canonical_nan(&mut instance); + c2036_l2054_assert_return_arithmetic_nan(&mut instance); + c2037_l2055_assert_return_canonical_nan(&mut instance); + c2038_l2056_assert_return_arithmetic_nan(&mut instance); + c2039_l2057_assert_return_canonical_nan(&mut instance); + c2040_l2058_assert_return_arithmetic_nan(&mut instance); + c2041_l2059_action_invoke(&mut instance); + c2042_l2060_action_invoke(&mut instance); + c2043_l2061_action_invoke(&mut instance); + c2044_l2062_action_invoke(&mut instance); + c2045_l2063_action_invoke(&mut instance); + c2046_l2064_action_invoke(&mut instance); + c2047_l2065_action_invoke(&mut instance); + c2048_l2066_action_invoke(&mut instance); + c2049_l2067_action_invoke(&mut instance); + c2050_l2068_action_invoke(&mut instance); + c2051_l2069_action_invoke(&mut instance); + c2052_l2070_action_invoke(&mut instance); + c2053_l2071_action_invoke(&mut instance); + c2054_l2072_action_invoke(&mut instance); + c2055_l2073_action_invoke(&mut instance); + c2056_l2074_action_invoke(&mut instance); + c2057_l2075_action_invoke(&mut instance); + c2058_l2076_action_invoke(&mut instance); + c2059_l2077_action_invoke(&mut instance); + c2060_l2078_action_invoke(&mut instance); + c2061_l2079_action_invoke(&mut instance); + c2062_l2080_action_invoke(&mut instance); + c2063_l2081_action_invoke(&mut instance); + c2064_l2082_action_invoke(&mut instance); + c2065_l2083_action_invoke(&mut instance); + c2066_l2084_action_invoke(&mut instance); + c2067_l2085_action_invoke(&mut instance); + c2068_l2086_action_invoke(&mut instance); + c2069_l2087_action_invoke(&mut instance); + c2070_l2088_action_invoke(&mut instance); + c2071_l2089_action_invoke(&mut instance); + c2072_l2090_action_invoke(&mut instance); + c2073_l2091_assert_return_canonical_nan(&mut instance); + c2074_l2092_assert_return_arithmetic_nan(&mut instance); + c2075_l2093_assert_return_canonical_nan(&mut instance); + c2076_l2094_assert_return_arithmetic_nan(&mut instance); + c2077_l2095_assert_return_canonical_nan(&mut instance); + c2078_l2096_assert_return_arithmetic_nan(&mut instance); + c2079_l2097_assert_return_canonical_nan(&mut instance); + c2080_l2098_assert_return_arithmetic_nan(&mut instance); + c2081_l2099_action_invoke(&mut instance); + c2082_l2100_action_invoke(&mut instance); + c2083_l2101_action_invoke(&mut instance); + c2084_l2102_action_invoke(&mut instance); + c2085_l2103_action_invoke(&mut instance); + c2086_l2104_action_invoke(&mut instance); + c2087_l2105_action_invoke(&mut instance); + c2088_l2106_action_invoke(&mut instance); + c2089_l2107_action_invoke(&mut instance); + c2090_l2108_action_invoke(&mut instance); + c2091_l2109_action_invoke(&mut instance); + c2092_l2110_action_invoke(&mut instance); + c2093_l2111_action_invoke(&mut instance); + c2094_l2112_action_invoke(&mut instance); + c2095_l2113_action_invoke(&mut instance); + c2096_l2114_action_invoke(&mut instance); + c2097_l2115_action_invoke(&mut instance); + c2098_l2116_action_invoke(&mut instance); + c2099_l2117_action_invoke(&mut instance); + c2100_l2118_action_invoke(&mut instance); + c2101_l2119_action_invoke(&mut instance); + c2102_l2120_action_invoke(&mut instance); + c2103_l2121_action_invoke(&mut instance); + c2104_l2122_action_invoke(&mut instance); + c2105_l2123_action_invoke(&mut instance); + c2106_l2124_action_invoke(&mut instance); + c2107_l2125_action_invoke(&mut instance); + c2108_l2126_action_invoke(&mut instance); + c2109_l2127_action_invoke(&mut instance); + c2110_l2128_action_invoke(&mut instance); + c2111_l2129_action_invoke(&mut instance); + c2112_l2130_action_invoke(&mut instance); + c2113_l2131_assert_return_canonical_nan(&mut instance); + c2114_l2132_assert_return_arithmetic_nan(&mut instance); + c2115_l2133_assert_return_canonical_nan(&mut instance); + c2116_l2134_assert_return_arithmetic_nan(&mut instance); + c2117_l2135_assert_return_canonical_nan(&mut instance); + c2118_l2136_assert_return_arithmetic_nan(&mut instance); + c2119_l2137_assert_return_canonical_nan(&mut instance); + c2120_l2138_assert_return_arithmetic_nan(&mut instance); + c2121_l2139_action_invoke(&mut instance); + c2122_l2140_action_invoke(&mut instance); + c2123_l2141_action_invoke(&mut instance); + c2124_l2142_action_invoke(&mut instance); + c2125_l2143_action_invoke(&mut instance); + c2126_l2144_action_invoke(&mut instance); + c2127_l2145_action_invoke(&mut instance); + c2128_l2146_action_invoke(&mut instance); + c2129_l2147_action_invoke(&mut instance); + c2130_l2148_action_invoke(&mut instance); + c2131_l2149_action_invoke(&mut instance); + c2132_l2150_action_invoke(&mut instance); + c2133_l2151_action_invoke(&mut instance); + c2134_l2152_action_invoke(&mut instance); + c2135_l2153_action_invoke(&mut instance); + c2136_l2154_action_invoke(&mut instance); + c2137_l2155_action_invoke(&mut instance); + c2138_l2156_action_invoke(&mut instance); + c2139_l2157_action_invoke(&mut instance); + c2140_l2158_action_invoke(&mut instance); + c2141_l2159_action_invoke(&mut instance); + c2142_l2160_action_invoke(&mut instance); + c2143_l2161_action_invoke(&mut instance); + c2144_l2162_action_invoke(&mut instance); + c2145_l2163_action_invoke(&mut instance); + c2146_l2164_action_invoke(&mut instance); + c2147_l2165_action_invoke(&mut instance); + c2148_l2166_action_invoke(&mut instance); + c2149_l2167_action_invoke(&mut instance); + c2150_l2168_action_invoke(&mut instance); + c2151_l2169_action_invoke(&mut instance); + c2152_l2170_action_invoke(&mut instance); + c2153_l2171_assert_return_canonical_nan(&mut instance); + c2154_l2172_assert_return_arithmetic_nan(&mut instance); + c2155_l2173_assert_return_canonical_nan(&mut instance); + c2156_l2174_assert_return_arithmetic_nan(&mut instance); + c2157_l2175_assert_return_canonical_nan(&mut instance); + c2158_l2176_assert_return_arithmetic_nan(&mut instance); + c2159_l2177_assert_return_canonical_nan(&mut instance); + c2160_l2178_assert_return_arithmetic_nan(&mut instance); + c2161_l2179_action_invoke(&mut instance); + c2162_l2180_action_invoke(&mut instance); + c2163_l2181_action_invoke(&mut instance); + c2164_l2182_action_invoke(&mut instance); + c2165_l2183_action_invoke(&mut instance); + c2166_l2184_action_invoke(&mut instance); + c2167_l2185_action_invoke(&mut instance); + c2168_l2186_action_invoke(&mut instance); + c2169_l2187_action_invoke(&mut instance); + c2170_l2188_action_invoke(&mut instance); + c2171_l2189_action_invoke(&mut instance); + c2172_l2190_action_invoke(&mut instance); + c2173_l2191_action_invoke(&mut instance); + c2174_l2192_action_invoke(&mut instance); + c2175_l2193_action_invoke(&mut instance); + c2176_l2194_action_invoke(&mut instance); + c2177_l2195_action_invoke(&mut instance); + c2178_l2196_action_invoke(&mut instance); + c2179_l2197_action_invoke(&mut instance); + c2180_l2198_action_invoke(&mut instance); + c2181_l2199_action_invoke(&mut instance); + c2182_l2200_action_invoke(&mut instance); + c2183_l2201_action_invoke(&mut instance); + c2184_l2202_action_invoke(&mut instance); + c2185_l2203_action_invoke(&mut instance); + c2186_l2204_action_invoke(&mut instance); + c2187_l2205_action_invoke(&mut instance); + c2188_l2206_action_invoke(&mut instance); + c2189_l2207_action_invoke(&mut instance); + c2190_l2208_action_invoke(&mut instance); + c2191_l2209_action_invoke(&mut instance); + c2192_l2210_action_invoke(&mut instance); + c2193_l2211_assert_return_canonical_nan(&mut instance); + c2194_l2212_assert_return_arithmetic_nan(&mut instance); + c2195_l2213_assert_return_canonical_nan(&mut instance); + c2196_l2214_assert_return_arithmetic_nan(&mut instance); + c2197_l2215_assert_return_canonical_nan(&mut instance); + c2198_l2216_assert_return_arithmetic_nan(&mut instance); + c2199_l2217_assert_return_canonical_nan(&mut instance); + c2200_l2218_assert_return_arithmetic_nan(&mut instance); + c2201_l2219_action_invoke(&mut instance); + c2202_l2220_action_invoke(&mut instance); + c2203_l2221_action_invoke(&mut instance); + c2204_l2222_action_invoke(&mut instance); + c2205_l2223_action_invoke(&mut instance); + c2206_l2224_action_invoke(&mut instance); + c2207_l2225_action_invoke(&mut instance); + c2208_l2226_action_invoke(&mut instance); + c2209_l2227_action_invoke(&mut instance); + c2210_l2228_action_invoke(&mut instance); + c2211_l2229_action_invoke(&mut instance); + c2212_l2230_action_invoke(&mut instance); + c2213_l2231_action_invoke(&mut instance); + c2214_l2232_action_invoke(&mut instance); + c2215_l2233_action_invoke(&mut instance); + c2216_l2234_action_invoke(&mut instance); + c2217_l2235_action_invoke(&mut instance); + c2218_l2236_action_invoke(&mut instance); + c2219_l2237_action_invoke(&mut instance); + c2220_l2238_action_invoke(&mut instance); + c2221_l2239_action_invoke(&mut instance); + c2222_l2240_action_invoke(&mut instance); + c2223_l2241_action_invoke(&mut instance); + c2224_l2242_action_invoke(&mut instance); + c2225_l2243_action_invoke(&mut instance); + c2226_l2244_action_invoke(&mut instance); + c2227_l2245_action_invoke(&mut instance); + c2228_l2246_action_invoke(&mut instance); + c2229_l2247_action_invoke(&mut instance); + c2230_l2248_action_invoke(&mut instance); + c2231_l2249_action_invoke(&mut instance); + c2232_l2250_action_invoke(&mut instance); + c2233_l2251_assert_return_canonical_nan(&mut instance); + c2234_l2252_assert_return_arithmetic_nan(&mut instance); + c2235_l2253_assert_return_canonical_nan(&mut instance); + c2236_l2254_assert_return_arithmetic_nan(&mut instance); + c2237_l2255_assert_return_canonical_nan(&mut instance); + c2238_l2256_assert_return_arithmetic_nan(&mut instance); + c2239_l2257_assert_return_canonical_nan(&mut instance); + c2240_l2258_assert_return_arithmetic_nan(&mut instance); + c2241_l2259_action_invoke(&mut instance); + c2242_l2260_action_invoke(&mut instance); + c2243_l2261_action_invoke(&mut instance); + c2244_l2262_action_invoke(&mut instance); + c2245_l2263_action_invoke(&mut instance); + c2246_l2264_action_invoke(&mut instance); + c2247_l2265_action_invoke(&mut instance); + c2248_l2266_action_invoke(&mut instance); + c2249_l2267_action_invoke(&mut instance); + c2250_l2268_action_invoke(&mut instance); + c2251_l2269_action_invoke(&mut instance); + c2252_l2270_action_invoke(&mut instance); + c2253_l2271_action_invoke(&mut instance); + c2254_l2272_action_invoke(&mut instance); + c2255_l2273_action_invoke(&mut instance); + c2256_l2274_action_invoke(&mut instance); + c2257_l2275_action_invoke(&mut instance); + c2258_l2276_action_invoke(&mut instance); + c2259_l2277_action_invoke(&mut instance); + c2260_l2278_action_invoke(&mut instance); + c2261_l2279_action_invoke(&mut instance); + c2262_l2280_action_invoke(&mut instance); + c2263_l2281_action_invoke(&mut instance); + c2264_l2282_action_invoke(&mut instance); + c2265_l2283_action_invoke(&mut instance); + c2266_l2284_action_invoke(&mut instance); + c2267_l2285_action_invoke(&mut instance); + c2268_l2286_action_invoke(&mut instance); + c2269_l2287_action_invoke(&mut instance); + c2270_l2288_action_invoke(&mut instance); + c2271_l2289_action_invoke(&mut instance); + c2272_l2290_action_invoke(&mut instance); + c2273_l2291_assert_return_canonical_nan(&mut instance); + c2274_l2292_assert_return_arithmetic_nan(&mut instance); + c2275_l2293_assert_return_canonical_nan(&mut instance); + c2276_l2294_assert_return_arithmetic_nan(&mut instance); + c2277_l2295_assert_return_canonical_nan(&mut instance); + c2278_l2296_assert_return_arithmetic_nan(&mut instance); + c2279_l2297_assert_return_canonical_nan(&mut instance); + c2280_l2298_assert_return_arithmetic_nan(&mut instance); + c2281_l2299_action_invoke(&mut instance); + c2282_l2300_action_invoke(&mut instance); + c2283_l2301_action_invoke(&mut instance); + c2284_l2302_action_invoke(&mut instance); + c2285_l2303_action_invoke(&mut instance); + c2286_l2304_action_invoke(&mut instance); + c2287_l2305_action_invoke(&mut instance); + c2288_l2306_action_invoke(&mut instance); + c2289_l2307_action_invoke(&mut instance); + c2290_l2308_action_invoke(&mut instance); + c2291_l2309_action_invoke(&mut instance); + c2292_l2310_action_invoke(&mut instance); + c2293_l2311_action_invoke(&mut instance); + c2294_l2312_action_invoke(&mut instance); + c2295_l2313_action_invoke(&mut instance); + c2296_l2314_action_invoke(&mut instance); + c2297_l2315_action_invoke(&mut instance); + c2298_l2316_action_invoke(&mut instance); + c2299_l2317_action_invoke(&mut instance); + c2300_l2318_action_invoke(&mut instance); + c2301_l2319_action_invoke(&mut instance); + c2302_l2320_action_invoke(&mut instance); + c2303_l2321_action_invoke(&mut instance); + c2304_l2322_action_invoke(&mut instance); + c2305_l2323_action_invoke(&mut instance); + c2306_l2324_action_invoke(&mut instance); + c2307_l2325_action_invoke(&mut instance); + c2308_l2326_action_invoke(&mut instance); + c2309_l2327_action_invoke(&mut instance); + c2310_l2328_action_invoke(&mut instance); + c2311_l2329_action_invoke(&mut instance); + c2312_l2330_action_invoke(&mut instance); + c2313_l2331_assert_return_canonical_nan(&mut instance); + c2314_l2332_assert_return_arithmetic_nan(&mut instance); + c2315_l2333_assert_return_canonical_nan(&mut instance); + c2316_l2334_assert_return_arithmetic_nan(&mut instance); + c2317_l2335_assert_return_canonical_nan(&mut instance); + c2318_l2336_assert_return_arithmetic_nan(&mut instance); + c2319_l2337_assert_return_canonical_nan(&mut instance); + c2320_l2338_assert_return_arithmetic_nan(&mut instance); + c2321_l2339_assert_return_canonical_nan(&mut instance); + c2322_l2340_assert_return_arithmetic_nan(&mut instance); + c2323_l2341_assert_return_canonical_nan(&mut instance); + c2324_l2342_assert_return_arithmetic_nan(&mut instance); + c2325_l2343_assert_return_canonical_nan(&mut instance); + c2326_l2344_assert_return_arithmetic_nan(&mut instance); + c2327_l2345_assert_return_canonical_nan(&mut instance); + c2328_l2346_assert_return_arithmetic_nan(&mut instance); + c2329_l2347_assert_return_canonical_nan(&mut instance); + c2330_l2348_assert_return_arithmetic_nan(&mut instance); + c2331_l2349_assert_return_canonical_nan(&mut instance); + c2332_l2350_assert_return_arithmetic_nan(&mut instance); + c2333_l2351_assert_return_canonical_nan(&mut instance); + c2334_l2352_assert_return_arithmetic_nan(&mut instance); + c2335_l2353_assert_return_canonical_nan(&mut instance); + c2336_l2354_assert_return_arithmetic_nan(&mut instance); + c2337_l2355_assert_return_canonical_nan(&mut instance); + c2338_l2356_assert_return_arithmetic_nan(&mut instance); + c2339_l2357_assert_return_canonical_nan(&mut instance); + c2340_l2358_assert_return_arithmetic_nan(&mut instance); + c2341_l2359_assert_return_canonical_nan(&mut instance); + c2342_l2360_assert_return_arithmetic_nan(&mut instance); + c2343_l2361_assert_return_canonical_nan(&mut instance); + c2344_l2362_assert_return_arithmetic_nan(&mut instance); + c2345_l2363_assert_return_canonical_nan(&mut instance); + c2346_l2364_assert_return_arithmetic_nan(&mut instance); + c2347_l2365_assert_return_canonical_nan(&mut instance); + c2348_l2366_assert_return_arithmetic_nan(&mut instance); + c2349_l2367_assert_return_canonical_nan(&mut instance); + c2350_l2368_assert_return_arithmetic_nan(&mut instance); + c2351_l2369_assert_return_canonical_nan(&mut instance); + c2352_l2370_assert_return_arithmetic_nan(&mut instance); + c2353_l2371_assert_return_canonical_nan(&mut instance); + c2354_l2372_assert_return_arithmetic_nan(&mut instance); + c2355_l2373_assert_return_canonical_nan(&mut instance); + c2356_l2374_assert_return_arithmetic_nan(&mut instance); + c2357_l2375_assert_return_canonical_nan(&mut instance); + c2358_l2376_assert_return_arithmetic_nan(&mut instance); + c2359_l2377_assert_return_canonical_nan(&mut instance); + c2360_l2378_assert_return_arithmetic_nan(&mut instance); + c2361_l2379_assert_return_canonical_nan(&mut instance); + c2362_l2380_assert_return_arithmetic_nan(&mut instance); + c2363_l2381_assert_return_canonical_nan(&mut instance); + c2364_l2382_assert_return_arithmetic_nan(&mut instance); + c2365_l2383_assert_return_canonical_nan(&mut instance); + c2366_l2384_assert_return_arithmetic_nan(&mut instance); + c2367_l2385_assert_return_canonical_nan(&mut instance); + c2368_l2386_assert_return_arithmetic_nan(&mut instance); + c2369_l2387_assert_return_canonical_nan(&mut instance); + c2370_l2388_assert_return_arithmetic_nan(&mut instance); + c2371_l2389_assert_return_canonical_nan(&mut instance); + c2372_l2390_assert_return_arithmetic_nan(&mut instance); + c2373_l2391_assert_return_canonical_nan(&mut instance); + c2374_l2392_assert_return_arithmetic_nan(&mut instance); + c2375_l2393_assert_return_canonical_nan(&mut instance); + c2376_l2394_assert_return_arithmetic_nan(&mut instance); + c2377_l2395_assert_return_canonical_nan(&mut instance); + c2378_l2396_assert_return_arithmetic_nan(&mut instance); + c2379_l2397_assert_return_canonical_nan(&mut instance); + c2380_l2398_assert_return_arithmetic_nan(&mut instance); + c2381_l2399_assert_return_canonical_nan(&mut instance); + c2382_l2400_assert_return_arithmetic_nan(&mut instance); + c2383_l2401_assert_return_canonical_nan(&mut instance); + c2384_l2402_assert_return_arithmetic_nan(&mut instance); + c2385_l2403_assert_return_canonical_nan(&mut instance); + c2386_l2404_assert_return_arithmetic_nan(&mut instance); + c2387_l2405_assert_return_arithmetic_nan(&mut instance); + c2388_l2406_assert_return_arithmetic_nan(&mut instance); + c2389_l2407_assert_return_canonical_nan(&mut instance); + c2390_l2408_assert_return_arithmetic_nan(&mut instance); + c2391_l2409_assert_return_arithmetic_nan(&mut instance); + c2392_l2410_assert_return_arithmetic_nan(&mut instance); + c2393_l2411_assert_return_canonical_nan(&mut instance); + c2394_l2412_assert_return_arithmetic_nan(&mut instance); + c2395_l2413_assert_return_arithmetic_nan(&mut instance); + c2396_l2414_assert_return_arithmetic_nan(&mut instance); + c2397_l2415_assert_return_canonical_nan(&mut instance); + c2398_l2416_assert_return_arithmetic_nan(&mut instance); + c2399_l2417_assert_return_arithmetic_nan(&mut instance); + c2400_l2418_assert_return_arithmetic_nan(&mut instance); + c2401_l2419_action_invoke(&mut instance); + c2402_l2420_action_invoke(&mut instance); + c2403_l2421_assert_return_canonical_nan(&mut instance); + c2404_l2422_action_invoke(&mut instance); + c2405_l2423_assert_return_canonical_nan(&mut instance); + c2406_l2424_action_invoke(&mut instance); + c2407_l2425_assert_return_canonical_nan(&mut instance); + c2408_l2426_action_invoke(&mut instance); + c2409_l2427_assert_return_canonical_nan(&mut instance); + c2410_l2428_action_invoke(&mut instance); + c2411_l2429_assert_return_canonical_nan(&mut instance); + c2412_l2430_action_invoke(&mut instance); + c2413_l2431_assert_return_canonical_nan(&mut instance); + c2414_l2432_action_invoke(&mut instance); + c2415_l2433_assert_return_canonical_nan(&mut instance); + c2416_l2434_action_invoke(&mut instance); + c2417_l2435_assert_return_canonical_nan(&mut instance); + c2418_l2436_assert_return_arithmetic_nan(&mut instance); + c2419_l2437_assert_return_canonical_nan(&mut instance); + c2420_l2438_assert_return_arithmetic_nan(&mut instance); + c2421_l2439_action_invoke(&mut instance); + c2422_l2440_action_invoke(&mut instance); + c2423_l2441_action_invoke(&mut instance); + c2424_l2442_action_invoke(&mut instance); + c2425_l2443_action_invoke(&mut instance); + c2426_l2444_action_invoke(&mut instance); + c2427_l2445_action_invoke(&mut instance); + c2428_l2446_action_invoke(&mut instance); + c2429_l2447_action_invoke(&mut instance); + c2430_l2448_action_invoke(&mut instance); + c2431_l2449_action_invoke(&mut instance); + c2432_l2450_action_invoke(&mut instance); + c2433_l2451_action_invoke(&mut instance); + c2434_l2452_action_invoke(&mut instance); + c2435_l2453_action_invoke(&mut instance); + c2436_l2454_action_invoke(&mut instance); + c2437_l2455_assert_return_canonical_nan(&mut instance); + c2438_l2456_assert_return_arithmetic_nan(&mut instance); + c2439_l2457_assert_return_canonical_nan(&mut instance); + c2440_l2458_assert_return_arithmetic_nan(&mut instance); + c2441_l2459_action_invoke(&mut instance); + c2442_l2460_action_invoke(&mut instance); + c2443_l2461_action_invoke(&mut instance); + c2444_l2462_action_invoke(&mut instance); + c2445_l2463_action_invoke(&mut instance); + c2446_l2464_action_invoke(&mut instance); + c2447_l2465_action_invoke(&mut instance); + c2448_l2466_action_invoke(&mut instance); + c2449_l2467_action_invoke(&mut instance); + c2450_l2468_action_invoke(&mut instance); + c2451_l2469_action_invoke(&mut instance); + c2452_l2470_action_invoke(&mut instance); + c2453_l2471_action_invoke(&mut instance); + c2454_l2472_action_invoke(&mut instance); + c2455_l2473_action_invoke(&mut instance); + c2456_l2474_action_invoke(&mut instance); + c2457_l2475_assert_return_canonical_nan(&mut instance); + c2458_l2476_assert_return_arithmetic_nan(&mut instance); + c2459_l2477_assert_return_canonical_nan(&mut instance); + c2460_l2478_assert_return_arithmetic_nan(&mut instance); + c2461_l2479_action_invoke(&mut instance); + c2462_l2480_action_invoke(&mut instance); + c2463_l2481_action_invoke(&mut instance); + c2464_l2482_action_invoke(&mut instance); + c2465_l2483_action_invoke(&mut instance); + c2466_l2484_action_invoke(&mut instance); + c2467_l2485_action_invoke(&mut instance); + c2468_l2486_action_invoke(&mut instance); + c2469_l2487_action_invoke(&mut instance); + c2470_l2488_action_invoke(&mut instance); + c2471_l2489_action_invoke(&mut instance); + c2472_l2490_action_invoke(&mut instance); + c2473_l2491_action_invoke(&mut instance); + c2474_l2492_action_invoke(&mut instance); + c2475_l2493_action_invoke(&mut instance); + c2476_l2494_action_invoke(&mut instance); + c2477_l2495_assert_return_canonical_nan(&mut instance); + c2478_l2496_assert_return_arithmetic_nan(&mut instance); + c2479_l2497_assert_return_canonical_nan(&mut instance); + c2480_l2498_assert_return_arithmetic_nan(&mut instance); + c2481_l2499_action_invoke(&mut instance); + c2482_l2500_action_invoke(&mut instance); + c2483_l2501_action_invoke(&mut instance); + c2484_l2502_action_invoke(&mut instance); + c2485_l2503_action_invoke(&mut instance); + c2486_l2504_action_invoke(&mut instance); + c2487_l2505_action_invoke(&mut instance); + c2488_l2506_action_invoke(&mut instance); + c2489_l2507_action_invoke(&mut instance); + c2490_l2508_action_invoke(&mut instance); + c2491_l2509_action_invoke(&mut instance); + c2492_l2510_action_invoke(&mut instance); + c2493_l2511_action_invoke(&mut instance); + c2494_l2512_action_invoke(&mut instance); + c2495_l2513_action_invoke(&mut instance); + c2496_l2514_action_invoke(&mut instance); + c2497_l2515_assert_return_canonical_nan(&mut instance); + c2498_l2516_assert_return_arithmetic_nan(&mut instance); + c2499_l2517_assert_return_canonical_nan(&mut instance); + c2500_l2518_assert_return_arithmetic_nan(&mut instance); +} diff --git a/lib/runtime/tests/spectests/f64_bitwise.rs b/lib/runtime/tests/spectests/f64_bitwise.rs new file mode 100644 index 000000000..514c6467a --- /dev/null +++ b/lib/runtime/tests/spectests/f64_bitwise.rs @@ -0,0 +1,3535 @@ +// 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/f64_bitwise.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 4 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func (param f64) (result f64))) + (type (;1;) (func (param f64 f64) (result f64))) + (func (;0;) (type 0) (param f64) (result f64) + get_local 0 + f64.abs) + (func (;1;) (type 0) (param f64) (result f64) + get_local 0 + f64.neg) + (func (;2;) (type 1) (param f64 f64) (result f64) + get_local 0 + get_local 1 + f64.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::F64((-0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).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::F64((-0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).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::F64((0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).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::F64((0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).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::F64((-0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).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::F64((-0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).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::F64((0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).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::F64((0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).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::F64((-0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).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::F64((-0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).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::F64((0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).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::F64((0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).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::F64((-0.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).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::F64((-0.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).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::F64((0.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).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::F64((0.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).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::F64((-0.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).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::F64((-0.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).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::F64((0.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).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::F64((0.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).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::F64((-0.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).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::F64((-0.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).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::F64((0.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).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::F64((0.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).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::F64((-0.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).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::F64((-0.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).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::F64((0.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).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::F64((0.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).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::F64((-0.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).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::F64((-0.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).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::F64((0.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).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::F64((0.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).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::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).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::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).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::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).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::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((-0.5f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).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::F64((-0.5f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).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::F64((0.5f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).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::F64((0.5f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).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::F64((-0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).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::F64((-0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).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::F64((0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).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::F64((0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).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::F64((-0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).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::F64((-0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).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::F64((0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).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::F64((0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).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::F64((-0.5f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).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::F64((-0.5f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).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::F64((0.5f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).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::F64((0.5f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).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::F64((-0.5f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).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::F64((-0.5f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).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::F64((0.5f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).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::F64((0.5f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).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::F64((-0.5f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).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::F64((-0.5f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).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::F64((0.5f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).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::F64((0.5f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).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::F64((-0.5f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).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::F64((-0.5f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).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::F64((0.5f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).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::F64((0.5f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).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::F64((-0.5f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).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::F64((-0.5f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).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::F64((0.5f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).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::F64((0.5f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).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::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).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::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).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::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).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::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).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::F64((-1.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).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::F64((-1.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).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::F64((1.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).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::F64((1.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).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::F64((-1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).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::F64((-1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).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::F64((1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).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::F64((1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).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::F64((-1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).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::F64((-1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).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::F64((1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).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::F64((1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).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::F64((-1.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).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::F64((-1.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).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::F64((1.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).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::F64((1.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).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::F64((-1.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).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::F64((-1.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).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::F64((1.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).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::F64((1.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).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::F64((-1.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).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::F64((-1.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).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::F64((1.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).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::F64((1.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).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::F64((-1.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).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::F64((-1.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).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::F64((1.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).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::F64((1.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).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::F64((-1.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).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::F64((-1.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).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::F64((1.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).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::F64((1.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).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::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).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::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).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::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).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::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).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::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).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::F64((-6.283185307179586f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).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::F64((6.283185307179586f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).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::F64((6.283185307179586f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).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::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).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::F64((-6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).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::F64((6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).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::F64((6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).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::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).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::F64((-6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).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::F64((6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).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::F64((6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).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::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).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::F64((-6.283185307179586f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).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::F64((6.283185307179586f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).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::F64((6.283185307179586f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).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::F64((-6.283185307179586f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).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::F64((-6.283185307179586f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).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::F64((6.283185307179586f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).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::F64((6.283185307179586f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).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::F64((-6.283185307179586f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).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::F64((-6.283185307179586f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).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::F64((6.283185307179586f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).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::F64((6.283185307179586f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).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::F64((-6.283185307179586f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).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::F64((-6.283185307179586f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).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::F64((6.283185307179586f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).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::F64((6.283185307179586f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).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::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).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::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).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::F64((6.283185307179586f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).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::F64((6.283185307179586f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).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::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).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::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).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::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).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::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).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::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::INFINITY.to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::INFINITY.to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::INFINITY.to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::INFINITY.to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::NEG_INFINITY.to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::INFINITY.to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::INFINITY.to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::NEG_INFINITY.to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::INFINITY.to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::INFINITY.to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::NEG_INFINITY.to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::INFINITY.to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::INFINITY.to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::INFINITY.to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::INFINITY.to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.0f64).to_bits())]); + let expected = f64::from_bits(18444492273895866368); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.0f64).to_bits())]); + let expected = f64::from_bits(9221120237041090560); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.0f64).to_bits())]); + let expected = f64::from_bits(18444492273895866368); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.0f64).to_bits())]); + let expected = f64::from_bits(9221120237041090560); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + let expected = f64::from_bits(18444492273895866368); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + let expected = f64::from_bits(9221120237041090560); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + let expected = f64::from_bits(18444492273895866368); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + let expected = f64::from_bits(9221120237041090560); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + let expected = f64::from_bits(18444492273895866368); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + let expected = f64::from_bits(9221120237041090560); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + let expected = f64::from_bits(18444492273895866368); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + let expected = f64::from_bits(9221120237041090560); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.5f64).to_bits())]); + let expected = f64::from_bits(18444492273895866368); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.5f64).to_bits())]); + let expected = f64::from_bits(9221120237041090560); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.5f64).to_bits())]); + let expected = f64::from_bits(18444492273895866368); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.5f64).to_bits())]); + let expected = f64::from_bits(9221120237041090560); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-1.0f64).to_bits())]); + let expected = f64::from_bits(18444492273895866368); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((1.0f64).to_bits())]); + let expected = f64::from_bits(9221120237041090560); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-1.0f64).to_bits())]); + let expected = f64::from_bits(18444492273895866368); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((1.0f64).to_bits())]); + let expected = f64::from_bits(9221120237041090560); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-6.283185307179586f64).to_bits())]); + let expected = f64::from_bits(18444492273895866368); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((6.283185307179586f64).to_bits())]); + let expected = f64::from_bits(9221120237041090560); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-6.283185307179586f64).to_bits())]); + let expected = f64::from_bits(18444492273895866368); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((6.283185307179586f64).to_bits())]); + let expected = f64::from_bits(9221120237041090560); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + let expected = f64::from_bits(18444492273895866368); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + let expected = f64::from_bits(9221120237041090560); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + let expected = f64::from_bits(18444492273895866368); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + let expected = f64::from_bits(9221120237041090560); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]); + let expected = f64::from_bits(18444492273895866368); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::INFINITY.to_bits())]); + let expected = f64::from_bits(9221120237041090560); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]); + let expected = f64::from_bits(18444492273895866368); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::INFINITY.to_bits())]); + let expected = f64::from_bits(9221120237041090560); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + let expected = f64::from_bits(18444492273895866368); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + let expected = f64::from_bits(9221120237041090560); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + let expected = f64::from_bits(18444492273895866368); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + let expected = f64::from_bits(9221120237041090560); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).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::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).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::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).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::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).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::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).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::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).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::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).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::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::from_bits(18444492273895866368) as u64)]); + let expected = f64::from_bits(9221120237041090560); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64(f64::from_bits(9221120237041090560) as u64)]); + let expected = f64::from_bits(9221120237041090560); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).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::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).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::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).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::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.5f64).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::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.5f64).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::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).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::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).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::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).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::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-6.283185307179586f64).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::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).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::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::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::F64(f64::from_bits(18444492273895866368) as u64)]); + let expected = f64::from_bits(9221120237041090560); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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::F64(f64::from_bits(9221120237041090560) as u64)]); + let expected = f64::from_bits(18444492273895866368); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).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); +} diff --git a/lib/runtime/tests/spectests/f64_cmp.rs b/lib/runtime/tests/spectests/f64_cmp.rs new file mode 100644 index 000000000..5a53ab088 --- /dev/null +++ b/lib/runtime/tests/spectests/f64_cmp.rs @@ -0,0 +1,21671 @@ +// 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/f64_cmp.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 4 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func (param f64 f64) (result i32))) + (func (;0;) (type 0) (param f64 f64) (result i32) + get_local 0 + get_local 1 + f64.eq) + (func (;1;) (type 0) (param f64 f64) (result i32) + get_local 0 + get_local 1 + f64.ne) + (func (;2;) (type 0) (param f64 f64) (result i32) + get_local 0 + get_local 1 + f64.lt) + (func (;3;) (type 0) (param f64 f64) (result i32) + get_local 0 + get_local 1 + f64.le) + (func (;4;) (type 0) (param f64 f64) (result i32) + get_local 0 + get_local 1 + f64.gt) + (func (;5;) (type 0) (param f64 f64) (result i32) + get_local 0 + get_local 1 + f64.ge) + (export \"eq\" (func 0)) + (export \"ne\" (func 1)) + (export \"lt\" (func 2)) + (export \"le\" (func 3)) + (export \"gt\" (func 4)) + (export \"ge\" (func 5))) + "; + 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 13 +fn c1_l13_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l13_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 14 +fn c2_l14_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l14_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 15 +fn c3_l15_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l15_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 16 +fn c4_l16_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l16_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 17 +fn c5_l17_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l17_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 18 +fn c6_l18_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l18_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 19 +fn c7_l19_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l19_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 20 +fn c8_l20_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l20_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 21 +fn c9_l21_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l21_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 22 +fn c10_l22_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c10_l22_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 23 +fn c11_l23_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c11_l23_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 24 +fn c12_l24_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c12_l24_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 25 +fn c13_l25_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c13_l25_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 26 +fn c14_l26_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c14_l26_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 27 +fn c15_l27_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c15_l27_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 28 +fn c16_l28_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c16_l28_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 29 +fn c17_l29_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c17_l29_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 30 +fn c18_l30_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c18_l30_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 31 +fn c19_l31_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c19_l31_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 32 +fn c20_l32_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c20_l32_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 33 +fn c21_l33_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c21_l33_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 34 +fn c22_l34_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c22_l34_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 35 +fn c23_l35_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c23_l35_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 36 +fn c24_l36_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c24_l36_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 37 +fn c25_l37_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c25_l37_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 38 +fn c26_l38_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c26_l38_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 39 +fn c27_l39_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c27_l39_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 40 +fn c28_l40_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c28_l40_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 41 +fn c29_l41_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c29_l41_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 42 +fn c30_l42_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c30_l42_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 43 +fn c31_l43_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c31_l43_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 44 +fn c32_l44_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c32_l44_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 45 +fn c33_l45_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c33_l45_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 46 +fn c34_l46_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c34_l46_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 47 +fn c35_l47_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c35_l47_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 48 +fn c36_l48_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c36_l48_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 49 +fn c37_l49_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c37_l49_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 50 +fn c38_l50_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c38_l50_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 51 +fn c39_l51_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c39_l51_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 52 +fn c40_l52_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c40_l52_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 53 +fn c41_l53_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c41_l53_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 54 +fn c42_l54_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c42_l54_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 55 +fn c43_l55_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c43_l55_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 56 +fn c44_l56_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c44_l56_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 57 +fn c45_l57_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c45_l57_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 58 +fn c46_l58_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c46_l58_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 59 +fn c47_l59_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c47_l59_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 60 +fn c48_l60_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c48_l60_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 61 +fn c49_l61_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c49_l61_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 62 +fn c50_l62_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c50_l62_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 63 +fn c51_l63_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c51_l63_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 64 +fn c52_l64_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c52_l64_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 65 +fn c53_l65_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c53_l65_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 66 +fn c54_l66_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c54_l66_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 67 +fn c55_l67_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c55_l67_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 68 +fn c56_l68_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c56_l68_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 69 +fn c57_l69_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c57_l69_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 70 +fn c58_l70_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c58_l70_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 71 +fn c59_l71_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c59_l71_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 72 +fn c60_l72_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c60_l72_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 73 +fn c61_l73_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c61_l73_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 74 +fn c62_l74_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c62_l74_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 75 +fn c63_l75_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c63_l75_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 76 +fn c64_l76_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c64_l76_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 77 +fn c65_l77_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c65_l77_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 78 +fn c66_l78_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c66_l78_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 79 +fn c67_l79_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c67_l79_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 80 +fn c68_l80_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c68_l80_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 81 +fn c69_l81_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c69_l81_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 82 +fn c70_l82_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c70_l82_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 83 +fn c71_l83_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c71_l83_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 84 +fn c72_l84_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c72_l84_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 85 +fn c73_l85_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c73_l85_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 86 +fn c74_l86_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c74_l86_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 87 +fn c75_l87_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c75_l87_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 88 +fn c76_l88_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c76_l88_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 89 +fn c77_l89_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c77_l89_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 90 +fn c78_l90_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c78_l90_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 91 +fn c79_l91_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c79_l91_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 92 +fn c80_l92_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c80_l92_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 93 +fn c81_l93_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c81_l93_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 94 +fn c82_l94_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c82_l94_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 95 +fn c83_l95_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c83_l95_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 96 +fn c84_l96_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c84_l96_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 97 +fn c85_l97_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c85_l97_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 98 +fn c86_l98_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c86_l98_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 99 +fn c87_l99_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c87_l99_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 100 +fn c88_l100_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c88_l100_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 101 +fn c89_l101_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c89_l101_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 102 +fn c90_l102_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c90_l102_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 103 +fn c91_l103_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c91_l103_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 104 +fn c92_l104_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c92_l104_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 105 +fn c93_l105_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c93_l105_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 106 +fn c94_l106_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c94_l106_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 107 +fn c95_l107_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c95_l107_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 108 +fn c96_l108_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c96_l108_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 109 +fn c97_l109_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c97_l109_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 110 +fn c98_l110_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c98_l110_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 111 +fn c99_l111_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c99_l111_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 112 +fn c100_l112_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c100_l112_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 113 +fn c101_l113_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c101_l113_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 114 +fn c102_l114_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c102_l114_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 115 +fn c103_l115_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c103_l115_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 116 +fn c104_l116_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c104_l116_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 117 +fn c105_l117_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c105_l117_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 118 +fn c106_l118_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c106_l118_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 119 +fn c107_l119_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c107_l119_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 120 +fn c108_l120_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c108_l120_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 121 +fn c109_l121_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c109_l121_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 122 +fn c110_l122_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c110_l122_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 123 +fn c111_l123_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c111_l123_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 124 +fn c112_l124_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c112_l124_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 125 +fn c113_l125_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c113_l125_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 126 +fn c114_l126_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c114_l126_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 127 +fn c115_l127_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c115_l127_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 128 +fn c116_l128_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c116_l128_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 129 +fn c117_l129_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c117_l129_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 130 +fn c118_l130_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c118_l130_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 131 +fn c119_l131_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c119_l131_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 132 +fn c120_l132_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c120_l132_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 133 +fn c121_l133_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c121_l133_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 134 +fn c122_l134_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c122_l134_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 135 +fn c123_l135_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c123_l135_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 136 +fn c124_l136_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c124_l136_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.5f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 137 +fn c125_l137_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c125_l137_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 138 +fn c126_l138_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c126_l138_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 139 +fn c127_l139_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c127_l139_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 140 +fn c128_l140_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c128_l140_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 141 +fn c129_l141_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c129_l141_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 142 +fn c130_l142_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c130_l142_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 143 +fn c131_l143_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c131_l143_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 144 +fn c132_l144_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c132_l144_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 145 +fn c133_l145_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c133_l145_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 146 +fn c134_l146_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c134_l146_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 147 +fn c135_l147_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c135_l147_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 148 +fn c136_l148_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c136_l148_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.5f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 149 +fn c137_l149_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c137_l149_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.5f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 150 +fn c138_l150_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c138_l150_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.5f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 151 +fn c139_l151_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c139_l151_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.5f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 152 +fn c140_l152_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c140_l152_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.5f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 153 +fn c141_l153_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c141_l153_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.5f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 154 +fn c142_l154_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c142_l154_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.5f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 155 +fn c143_l155_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c143_l155_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.5f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 156 +fn c144_l156_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c144_l156_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.5f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 157 +fn c145_l157_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c145_l157_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.5f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 158 +fn c146_l158_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c146_l158_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.5f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 159 +fn c147_l159_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c147_l159_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.5f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 160 +fn c148_l160_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c148_l160_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.5f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 161 +fn c149_l161_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c149_l161_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 162 +fn c150_l162_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c150_l162_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 163 +fn c151_l163_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c151_l163_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 164 +fn c152_l164_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c152_l164_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 165 +fn c153_l165_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c153_l165_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 166 +fn c154_l166_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c154_l166_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 167 +fn c155_l167_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c155_l167_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 168 +fn c156_l168_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c156_l168_action_invoke"); + let result = instance.call("eq", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 169 +fn c157_l169_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c157_l169_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 170 +fn c158_l170_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c158_l170_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 171 +fn c159_l171_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c159_l171_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 172 +fn c160_l172_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c160_l172_action_invoke"); + let result = instance.call("eq", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 173 +fn c161_l173_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c161_l173_action_invoke"); + let result = instance.call("eq", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 174 +fn c162_l174_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c162_l174_action_invoke"); + let result = instance.call("eq", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 175 +fn c163_l175_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c163_l175_action_invoke"); + let result = instance.call("eq", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 176 +fn c164_l176_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c164_l176_action_invoke"); + let result = instance.call("eq", &[Value::F64((1.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 177 +fn c165_l177_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c165_l177_action_invoke"); + let result = instance.call("eq", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 178 +fn c166_l178_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c166_l178_action_invoke"); + let result = instance.call("eq", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 179 +fn c167_l179_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c167_l179_action_invoke"); + let result = instance.call("eq", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 180 +fn c168_l180_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c168_l180_action_invoke"); + let result = instance.call("eq", &[Value::F64((1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 181 +fn c169_l181_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c169_l181_action_invoke"); + let result = instance.call("eq", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 182 +fn c170_l182_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c170_l182_action_invoke"); + let result = instance.call("eq", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 183 +fn c171_l183_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c171_l183_action_invoke"); + let result = instance.call("eq", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 184 +fn c172_l184_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c172_l184_action_invoke"); + let result = instance.call("eq", &[Value::F64((1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 185 +fn c173_l185_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c173_l185_action_invoke"); + let result = instance.call("eq", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 186 +fn c174_l186_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c174_l186_action_invoke"); + let result = instance.call("eq", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 187 +fn c175_l187_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c175_l187_action_invoke"); + let result = instance.call("eq", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 188 +fn c176_l188_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c176_l188_action_invoke"); + let result = instance.call("eq", &[Value::F64((1.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 189 +fn c177_l189_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c177_l189_action_invoke"); + let result = instance.call("eq", &[Value::F64((-1.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 190 +fn c178_l190_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c178_l190_action_invoke"); + let result = instance.call("eq", &[Value::F64((-1.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 191 +fn c179_l191_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c179_l191_action_invoke"); + let result = instance.call("eq", &[Value::F64((1.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 192 +fn c180_l192_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c180_l192_action_invoke"); + let result = instance.call("eq", &[Value::F64((1.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 193 +fn c181_l193_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c181_l193_action_invoke"); + let result = instance.call("eq", &[Value::F64((-1.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 194 +fn c182_l194_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c182_l194_action_invoke"); + let result = instance.call("eq", &[Value::F64((-1.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 195 +fn c183_l195_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c183_l195_action_invoke"); + let result = instance.call("eq", &[Value::F64((1.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 196 +fn c184_l196_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c184_l196_action_invoke"); + let result = instance.call("eq", &[Value::F64((1.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 197 +fn c185_l197_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c185_l197_action_invoke"); + let result = instance.call("eq", &[Value::F64((-1.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 198 +fn c186_l198_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c186_l198_action_invoke"); + let result = instance.call("eq", &[Value::F64((-1.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 199 +fn c187_l199_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c187_l199_action_invoke"); + let result = instance.call("eq", &[Value::F64((1.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 200 +fn c188_l200_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c188_l200_action_invoke"); + let result = instance.call("eq", &[Value::F64((1.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 201 +fn c189_l201_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c189_l201_action_invoke"); + let result = instance.call("eq", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 202 +fn c190_l202_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c190_l202_action_invoke"); + let result = instance.call("eq", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 203 +fn c191_l203_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c191_l203_action_invoke"); + let result = instance.call("eq", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 204 +fn c192_l204_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c192_l204_action_invoke"); + let result = instance.call("eq", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 205 +fn c193_l205_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c193_l205_action_invoke"); + let result = instance.call("eq", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 206 +fn c194_l206_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c194_l206_action_invoke"); + let result = instance.call("eq", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 207 +fn c195_l207_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c195_l207_action_invoke"); + let result = instance.call("eq", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 208 +fn c196_l208_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c196_l208_action_invoke"); + let result = instance.call("eq", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 209 +fn c197_l209_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c197_l209_action_invoke"); + let result = instance.call("eq", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 210 +fn c198_l210_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c198_l210_action_invoke"); + let result = instance.call("eq", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 211 +fn c199_l211_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c199_l211_action_invoke"); + let result = instance.call("eq", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 212 +fn c200_l212_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c200_l212_action_invoke"); + let result = instance.call("eq", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 213 +fn c201_l213_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c201_l213_action_invoke"); + let result = instance.call("eq", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 214 +fn c202_l214_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c202_l214_action_invoke"); + let result = instance.call("eq", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 215 +fn c203_l215_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c203_l215_action_invoke"); + let result = instance.call("eq", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 216 +fn c204_l216_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c204_l216_action_invoke"); + let result = instance.call("eq", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 217 +fn c205_l217_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c205_l217_action_invoke"); + let result = instance.call("eq", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 218 +fn c206_l218_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c206_l218_action_invoke"); + let result = instance.call("eq", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 219 +fn c207_l219_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c207_l219_action_invoke"); + let result = instance.call("eq", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 220 +fn c208_l220_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c208_l220_action_invoke"); + let result = instance.call("eq", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 221 +fn c209_l221_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c209_l221_action_invoke"); + let result = instance.call("eq", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 222 +fn c210_l222_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c210_l222_action_invoke"); + let result = instance.call("eq", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 223 +fn c211_l223_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c211_l223_action_invoke"); + let result = instance.call("eq", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 224 +fn c212_l224_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c212_l224_action_invoke"); + let result = instance.call("eq", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 225 +fn c213_l225_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c213_l225_action_invoke"); + let result = instance.call("eq", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 226 +fn c214_l226_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c214_l226_action_invoke"); + let result = instance.call("eq", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 227 +fn c215_l227_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c215_l227_action_invoke"); + let result = instance.call("eq", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 228 +fn c216_l228_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c216_l228_action_invoke"); + let result = instance.call("eq", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 229 +fn c217_l229_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c217_l229_action_invoke"); + let result = instance.call("eq", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 230 +fn c218_l230_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c218_l230_action_invoke"); + let result = instance.call("eq", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 231 +fn c219_l231_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c219_l231_action_invoke"); + let result = instance.call("eq", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 232 +fn c220_l232_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c220_l232_action_invoke"); + let result = instance.call("eq", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 233 +fn c221_l233_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c221_l233_action_invoke"); + let result = instance.call("eq", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 234 +fn c222_l234_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c222_l234_action_invoke"); + let result = instance.call("eq", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 235 +fn c223_l235_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c223_l235_action_invoke"); + let result = instance.call("eq", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 236 +fn c224_l236_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c224_l236_action_invoke"); + let result = instance.call("eq", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 237 +fn c225_l237_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c225_l237_action_invoke"); + let result = instance.call("eq", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 238 +fn c226_l238_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c226_l238_action_invoke"); + let result = instance.call("eq", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 239 +fn c227_l239_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c227_l239_action_invoke"); + let result = instance.call("eq", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 240 +fn c228_l240_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c228_l240_action_invoke"); + let result = instance.call("eq", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 241 +fn c229_l241_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c229_l241_action_invoke"); + let result = instance.call("eq", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 242 +fn c230_l242_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c230_l242_action_invoke"); + let result = instance.call("eq", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 243 +fn c231_l243_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c231_l243_action_invoke"); + let result = instance.call("eq", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 244 +fn c232_l244_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c232_l244_action_invoke"); + let result = instance.call("eq", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 245 +fn c233_l245_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c233_l245_action_invoke"); + let result = instance.call("eq", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 246 +fn c234_l246_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c234_l246_action_invoke"); + let result = instance.call("eq", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 247 +fn c235_l247_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c235_l247_action_invoke"); + let result = instance.call("eq", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 248 +fn c236_l248_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c236_l248_action_invoke"); + let result = instance.call("eq", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 249 +fn c237_l249_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c237_l249_action_invoke"); + let result = instance.call("eq", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 250 +fn c238_l250_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c238_l250_action_invoke"); + let result = instance.call("eq", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 251 +fn c239_l251_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c239_l251_action_invoke"); + let result = instance.call("eq", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 252 +fn c240_l252_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c240_l252_action_invoke"); + let result = instance.call("eq", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 253 +fn c241_l253_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c241_l253_action_invoke"); + let result = instance.call("eq", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 254 +fn c242_l254_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c242_l254_action_invoke"); + let result = instance.call("eq", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 255 +fn c243_l255_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c243_l255_action_invoke"); + let result = instance.call("eq", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 256 +fn c244_l256_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c244_l256_action_invoke"); + let result = instance.call("eq", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 257 +fn c245_l257_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c245_l257_action_invoke"); + let result = instance.call("eq", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 258 +fn c246_l258_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c246_l258_action_invoke"); + let result = instance.call("eq", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 259 +fn c247_l259_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c247_l259_action_invoke"); + let result = instance.call("eq", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 260 +fn c248_l260_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c248_l260_action_invoke"); + let result = instance.call("eq", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 261 +fn c249_l261_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c249_l261_action_invoke"); + let result = instance.call("eq", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 262 +fn c250_l262_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c250_l262_action_invoke"); + let result = instance.call("eq", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 263 +fn c251_l263_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c251_l263_action_invoke"); + let result = instance.call("eq", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 264 +fn c252_l264_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c252_l264_action_invoke"); + let result = instance.call("eq", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 265 +fn c253_l265_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c253_l265_action_invoke"); + let result = instance.call("eq", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 266 +fn c254_l266_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c254_l266_action_invoke"); + let result = instance.call("eq", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 267 +fn c255_l267_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c255_l267_action_invoke"); + let result = instance.call("eq", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 268 +fn c256_l268_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c256_l268_action_invoke"); + let result = instance.call("eq", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 269 +fn c257_l269_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c257_l269_action_invoke"); + let result = instance.call("eq", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 270 +fn c258_l270_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c258_l270_action_invoke"); + let result = instance.call("eq", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 271 +fn c259_l271_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c259_l271_action_invoke"); + let result = instance.call("eq", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 272 +fn c260_l272_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c260_l272_action_invoke"); + let result = instance.call("eq", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 273 +fn c261_l273_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c261_l273_action_invoke"); + let result = instance.call("eq", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 274 +fn c262_l274_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c262_l274_action_invoke"); + let result = instance.call("eq", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 275 +fn c263_l275_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c263_l275_action_invoke"); + let result = instance.call("eq", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 276 +fn c264_l276_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c264_l276_action_invoke"); + let result = instance.call("eq", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 277 +fn c265_l277_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c265_l277_action_invoke"); + let result = instance.call("eq", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 278 +fn c266_l278_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c266_l278_action_invoke"); + let result = instance.call("eq", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 279 +fn c267_l279_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c267_l279_action_invoke"); + let result = instance.call("eq", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 280 +fn c268_l280_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c268_l280_action_invoke"); + let result = instance.call("eq", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 281 +fn c269_l281_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c269_l281_action_invoke"); + let result = instance.call("eq", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 282 +fn c270_l282_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c270_l282_action_invoke"); + let result = instance.call("eq", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 283 +fn c271_l283_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c271_l283_action_invoke"); + let result = instance.call("eq", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 284 +fn c272_l284_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c272_l284_action_invoke"); + let result = instance.call("eq", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 285 +fn c273_l285_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c273_l285_action_invoke"); + let result = instance.call("eq", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 286 +fn c274_l286_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c274_l286_action_invoke"); + let result = instance.call("eq", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 287 +fn c275_l287_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c275_l287_action_invoke"); + let result = instance.call("eq", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 288 +fn c276_l288_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c276_l288_action_invoke"); + let result = instance.call("eq", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 289 +fn c277_l289_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c277_l289_action_invoke"); + let result = instance.call("eq", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 290 +fn c278_l290_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c278_l290_action_invoke"); + let result = instance.call("eq", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 291 +fn c279_l291_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c279_l291_action_invoke"); + let result = instance.call("eq", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 292 +fn c280_l292_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c280_l292_action_invoke"); + let result = instance.call("eq", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 293 +fn c281_l293_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c281_l293_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 294 +fn c282_l294_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c282_l294_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 295 +fn c283_l295_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c283_l295_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 296 +fn c284_l296_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c284_l296_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 297 +fn c285_l297_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c285_l297_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 298 +fn c286_l298_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c286_l298_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 299 +fn c287_l299_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c287_l299_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 300 +fn c288_l300_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c288_l300_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 301 +fn c289_l301_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c289_l301_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 302 +fn c290_l302_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c290_l302_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 303 +fn c291_l303_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c291_l303_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 304 +fn c292_l304_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c292_l304_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 305 +fn c293_l305_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c293_l305_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 306 +fn c294_l306_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c294_l306_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 307 +fn c295_l307_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c295_l307_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 308 +fn c296_l308_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c296_l308_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 309 +fn c297_l309_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c297_l309_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 310 +fn c298_l310_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c298_l310_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 311 +fn c299_l311_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c299_l311_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 312 +fn c300_l312_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c300_l312_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 313 +fn c301_l313_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c301_l313_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 314 +fn c302_l314_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c302_l314_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 315 +fn c303_l315_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c303_l315_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 316 +fn c304_l316_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c304_l316_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 317 +fn c305_l317_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c305_l317_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 318 +fn c306_l318_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c306_l318_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 319 +fn c307_l319_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c307_l319_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 320 +fn c308_l320_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c308_l320_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 321 +fn c309_l321_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c309_l321_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 322 +fn c310_l322_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c310_l322_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 323 +fn c311_l323_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c311_l323_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 324 +fn c312_l324_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c312_l324_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 325 +fn c313_l325_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c313_l325_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 326 +fn c314_l326_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c314_l326_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 327 +fn c315_l327_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c315_l327_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 328 +fn c316_l328_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c316_l328_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 329 +fn c317_l329_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c317_l329_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 330 +fn c318_l330_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c318_l330_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 331 +fn c319_l331_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c319_l331_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 332 +fn c320_l332_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c320_l332_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 333 +fn c321_l333_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c321_l333_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 334 +fn c322_l334_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c322_l334_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 335 +fn c323_l335_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c323_l335_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 336 +fn c324_l336_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c324_l336_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 337 +fn c325_l337_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c325_l337_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 338 +fn c326_l338_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c326_l338_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 339 +fn c327_l339_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c327_l339_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 340 +fn c328_l340_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c328_l340_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 341 +fn c329_l341_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c329_l341_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 342 +fn c330_l342_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c330_l342_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 343 +fn c331_l343_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c331_l343_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 344 +fn c332_l344_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c332_l344_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 345 +fn c333_l345_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c333_l345_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 346 +fn c334_l346_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c334_l346_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 347 +fn c335_l347_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c335_l347_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 348 +fn c336_l348_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c336_l348_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 349 +fn c337_l349_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c337_l349_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 350 +fn c338_l350_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c338_l350_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 351 +fn c339_l351_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c339_l351_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 352 +fn c340_l352_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c340_l352_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 353 +fn c341_l353_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c341_l353_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 354 +fn c342_l354_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c342_l354_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 355 +fn c343_l355_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c343_l355_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 356 +fn c344_l356_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c344_l356_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 357 +fn c345_l357_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c345_l357_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 358 +fn c346_l358_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c346_l358_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 359 +fn c347_l359_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c347_l359_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 360 +fn c348_l360_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c348_l360_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 361 +fn c349_l361_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c349_l361_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 362 +fn c350_l362_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c350_l362_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 363 +fn c351_l363_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c351_l363_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 364 +fn c352_l364_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c352_l364_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 365 +fn c353_l365_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c353_l365_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 366 +fn c354_l366_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c354_l366_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 367 +fn c355_l367_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c355_l367_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 368 +fn c356_l368_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c356_l368_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 369 +fn c357_l369_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c357_l369_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 370 +fn c358_l370_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c358_l370_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 371 +fn c359_l371_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c359_l371_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 372 +fn c360_l372_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c360_l372_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 373 +fn c361_l373_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c361_l373_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 374 +fn c362_l374_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c362_l374_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 375 +fn c363_l375_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c363_l375_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 376 +fn c364_l376_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c364_l376_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 377 +fn c365_l377_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c365_l377_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 378 +fn c366_l378_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c366_l378_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 379 +fn c367_l379_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c367_l379_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 380 +fn c368_l380_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c368_l380_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 381 +fn c369_l381_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c369_l381_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 382 +fn c370_l382_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c370_l382_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 383 +fn c371_l383_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c371_l383_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 384 +fn c372_l384_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c372_l384_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 385 +fn c373_l385_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c373_l385_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 386 +fn c374_l386_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c374_l386_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 387 +fn c375_l387_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c375_l387_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 388 +fn c376_l388_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c376_l388_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 389 +fn c377_l389_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c377_l389_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 390 +fn c378_l390_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c378_l390_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 391 +fn c379_l391_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c379_l391_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 392 +fn c380_l392_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c380_l392_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 393 +fn c381_l393_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c381_l393_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 394 +fn c382_l394_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c382_l394_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 395 +fn c383_l395_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c383_l395_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 396 +fn c384_l396_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c384_l396_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 397 +fn c385_l397_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c385_l397_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 398 +fn c386_l398_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c386_l398_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 399 +fn c387_l399_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c387_l399_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 400 +fn c388_l400_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c388_l400_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 401 +fn c389_l401_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c389_l401_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 402 +fn c390_l402_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c390_l402_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 403 +fn c391_l403_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c391_l403_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 404 +fn c392_l404_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c392_l404_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 405 +fn c393_l405_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c393_l405_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 406 +fn c394_l406_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c394_l406_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 407 +fn c395_l407_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c395_l407_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 408 +fn c396_l408_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c396_l408_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 409 +fn c397_l409_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c397_l409_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 410 +fn c398_l410_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c398_l410_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 411 +fn c399_l411_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c399_l411_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 412 +fn c400_l412_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c400_l412_action_invoke"); + let result = instance.call("eq", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 413 +fn c401_l413_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c401_l413_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 414 +fn c402_l414_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c402_l414_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 415 +fn c403_l415_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c403_l415_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 416 +fn c404_l416_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c404_l416_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 417 +fn c405_l417_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c405_l417_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 418 +fn c406_l418_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c406_l418_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 419 +fn c407_l419_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c407_l419_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 420 +fn c408_l420_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c408_l420_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 421 +fn c409_l421_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c409_l421_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 422 +fn c410_l422_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c410_l422_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 423 +fn c411_l423_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c411_l423_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 424 +fn c412_l424_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c412_l424_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 425 +fn c413_l425_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c413_l425_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 426 +fn c414_l426_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c414_l426_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 427 +fn c415_l427_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c415_l427_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 428 +fn c416_l428_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c416_l428_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 429 +fn c417_l429_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c417_l429_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 430 +fn c418_l430_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c418_l430_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 431 +fn c419_l431_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c419_l431_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 432 +fn c420_l432_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c420_l432_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 433 +fn c421_l433_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c421_l433_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 434 +fn c422_l434_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c422_l434_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 435 +fn c423_l435_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c423_l435_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 436 +fn c424_l436_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c424_l436_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 437 +fn c425_l437_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c425_l437_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 438 +fn c426_l438_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c426_l438_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 439 +fn c427_l439_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c427_l439_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 440 +fn c428_l440_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c428_l440_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 441 +fn c429_l441_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c429_l441_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 442 +fn c430_l442_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c430_l442_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 443 +fn c431_l443_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c431_l443_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 444 +fn c432_l444_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c432_l444_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 445 +fn c433_l445_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c433_l445_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 446 +fn c434_l446_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c434_l446_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 447 +fn c435_l447_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c435_l447_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 448 +fn c436_l448_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c436_l448_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 449 +fn c437_l449_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c437_l449_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 450 +fn c438_l450_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c438_l450_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 451 +fn c439_l451_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c439_l451_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 452 +fn c440_l452_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c440_l452_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 453 +fn c441_l453_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c441_l453_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 454 +fn c442_l454_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c442_l454_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 455 +fn c443_l455_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c443_l455_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 456 +fn c444_l456_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c444_l456_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 457 +fn c445_l457_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c445_l457_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 458 +fn c446_l458_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c446_l458_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 459 +fn c447_l459_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c447_l459_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 460 +fn c448_l460_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c448_l460_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 461 +fn c449_l461_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c449_l461_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 462 +fn c450_l462_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c450_l462_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 463 +fn c451_l463_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c451_l463_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 464 +fn c452_l464_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c452_l464_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 465 +fn c453_l465_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c453_l465_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 466 +fn c454_l466_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c454_l466_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 467 +fn c455_l467_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c455_l467_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 468 +fn c456_l468_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c456_l468_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 469 +fn c457_l469_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c457_l469_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 470 +fn c458_l470_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c458_l470_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 471 +fn c459_l471_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c459_l471_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 472 +fn c460_l472_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c460_l472_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 473 +fn c461_l473_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c461_l473_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 474 +fn c462_l474_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c462_l474_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 475 +fn c463_l475_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c463_l475_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 476 +fn c464_l476_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c464_l476_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 477 +fn c465_l477_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c465_l477_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 478 +fn c466_l478_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c466_l478_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 479 +fn c467_l479_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c467_l479_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 480 +fn c468_l480_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c468_l480_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 481 +fn c469_l481_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c469_l481_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 482 +fn c470_l482_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c470_l482_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 483 +fn c471_l483_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c471_l483_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 484 +fn c472_l484_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c472_l484_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 485 +fn c473_l485_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c473_l485_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 486 +fn c474_l486_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c474_l486_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 487 +fn c475_l487_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c475_l487_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 488 +fn c476_l488_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c476_l488_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 489 +fn c477_l489_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c477_l489_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 490 +fn c478_l490_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c478_l490_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 491 +fn c479_l491_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c479_l491_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 492 +fn c480_l492_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c480_l492_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 493 +fn c481_l493_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c481_l493_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 494 +fn c482_l494_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c482_l494_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 495 +fn c483_l495_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c483_l495_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 496 +fn c484_l496_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c484_l496_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 497 +fn c485_l497_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c485_l497_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 498 +fn c486_l498_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c486_l498_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 499 +fn c487_l499_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c487_l499_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 500 +fn c488_l500_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c488_l500_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 501 +fn c489_l501_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c489_l501_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 502 +fn c490_l502_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c490_l502_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 503 +fn c491_l503_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c491_l503_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 504 +fn c492_l504_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c492_l504_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 505 +fn c493_l505_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c493_l505_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 506 +fn c494_l506_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c494_l506_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 507 +fn c495_l507_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c495_l507_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 508 +fn c496_l508_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c496_l508_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 509 +fn c497_l509_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c497_l509_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 510 +fn c498_l510_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c498_l510_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 511 +fn c499_l511_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c499_l511_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 512 +fn c500_l512_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c500_l512_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 513 +fn c501_l513_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c501_l513_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 514 +fn c502_l514_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c502_l514_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 515 +fn c503_l515_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c503_l515_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 516 +fn c504_l516_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c504_l516_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 517 +fn c505_l517_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c505_l517_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 518 +fn c506_l518_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c506_l518_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 519 +fn c507_l519_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c507_l519_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 520 +fn c508_l520_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c508_l520_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 521 +fn c509_l521_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c509_l521_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 522 +fn c510_l522_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c510_l522_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 523 +fn c511_l523_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c511_l523_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 524 +fn c512_l524_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c512_l524_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 525 +fn c513_l525_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c513_l525_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 526 +fn c514_l526_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c514_l526_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 527 +fn c515_l527_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c515_l527_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 528 +fn c516_l528_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c516_l528_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 529 +fn c517_l529_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c517_l529_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 530 +fn c518_l530_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c518_l530_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 531 +fn c519_l531_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c519_l531_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 532 +fn c520_l532_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c520_l532_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 533 +fn c521_l533_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c521_l533_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 534 +fn c522_l534_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c522_l534_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 535 +fn c523_l535_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c523_l535_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 536 +fn c524_l536_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c524_l536_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.5f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 537 +fn c525_l537_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c525_l537_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 538 +fn c526_l538_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c526_l538_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 539 +fn c527_l539_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c527_l539_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 540 +fn c528_l540_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c528_l540_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 541 +fn c529_l541_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c529_l541_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 542 +fn c530_l542_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c530_l542_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 543 +fn c531_l543_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c531_l543_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 544 +fn c532_l544_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c532_l544_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 545 +fn c533_l545_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c533_l545_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 546 +fn c534_l546_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c534_l546_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 547 +fn c535_l547_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c535_l547_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 548 +fn c536_l548_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c536_l548_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.5f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 549 +fn c537_l549_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c537_l549_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.5f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 550 +fn c538_l550_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c538_l550_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.5f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 551 +fn c539_l551_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c539_l551_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.5f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 552 +fn c540_l552_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c540_l552_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.5f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 553 +fn c541_l553_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c541_l553_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.5f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 554 +fn c542_l554_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c542_l554_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.5f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 555 +fn c543_l555_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c543_l555_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.5f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 556 +fn c544_l556_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c544_l556_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.5f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 557 +fn c545_l557_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c545_l557_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.5f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 558 +fn c546_l558_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c546_l558_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.5f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 559 +fn c547_l559_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c547_l559_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.5f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 560 +fn c548_l560_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c548_l560_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.5f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 561 +fn c549_l561_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c549_l561_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 562 +fn c550_l562_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c550_l562_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 563 +fn c551_l563_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c551_l563_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 564 +fn c552_l564_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c552_l564_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 565 +fn c553_l565_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c553_l565_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 566 +fn c554_l566_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c554_l566_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 567 +fn c555_l567_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c555_l567_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 568 +fn c556_l568_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c556_l568_action_invoke"); + let result = instance.call("ne", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 569 +fn c557_l569_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c557_l569_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 570 +fn c558_l570_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c558_l570_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 571 +fn c559_l571_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c559_l571_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 572 +fn c560_l572_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c560_l572_action_invoke"); + let result = instance.call("ne", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 573 +fn c561_l573_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c561_l573_action_invoke"); + let result = instance.call("ne", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 574 +fn c562_l574_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c562_l574_action_invoke"); + let result = instance.call("ne", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 575 +fn c563_l575_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c563_l575_action_invoke"); + let result = instance.call("ne", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 576 +fn c564_l576_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c564_l576_action_invoke"); + let result = instance.call("ne", &[Value::F64((1.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 577 +fn c565_l577_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c565_l577_action_invoke"); + let result = instance.call("ne", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 578 +fn c566_l578_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c566_l578_action_invoke"); + let result = instance.call("ne", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 579 +fn c567_l579_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c567_l579_action_invoke"); + let result = instance.call("ne", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 580 +fn c568_l580_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c568_l580_action_invoke"); + let result = instance.call("ne", &[Value::F64((1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 581 +fn c569_l581_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c569_l581_action_invoke"); + let result = instance.call("ne", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 582 +fn c570_l582_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c570_l582_action_invoke"); + let result = instance.call("ne", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 583 +fn c571_l583_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c571_l583_action_invoke"); + let result = instance.call("ne", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 584 +fn c572_l584_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c572_l584_action_invoke"); + let result = instance.call("ne", &[Value::F64((1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 585 +fn c573_l585_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c573_l585_action_invoke"); + let result = instance.call("ne", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 586 +fn c574_l586_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c574_l586_action_invoke"); + let result = instance.call("ne", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 587 +fn c575_l587_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c575_l587_action_invoke"); + let result = instance.call("ne", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 588 +fn c576_l588_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c576_l588_action_invoke"); + let result = instance.call("ne", &[Value::F64((1.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 589 +fn c577_l589_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c577_l589_action_invoke"); + let result = instance.call("ne", &[Value::F64((-1.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 590 +fn c578_l590_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c578_l590_action_invoke"); + let result = instance.call("ne", &[Value::F64((-1.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 591 +fn c579_l591_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c579_l591_action_invoke"); + let result = instance.call("ne", &[Value::F64((1.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 592 +fn c580_l592_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c580_l592_action_invoke"); + let result = instance.call("ne", &[Value::F64((1.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 593 +fn c581_l593_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c581_l593_action_invoke"); + let result = instance.call("ne", &[Value::F64((-1.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 594 +fn c582_l594_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c582_l594_action_invoke"); + let result = instance.call("ne", &[Value::F64((-1.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 595 +fn c583_l595_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c583_l595_action_invoke"); + let result = instance.call("ne", &[Value::F64((1.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 596 +fn c584_l596_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c584_l596_action_invoke"); + let result = instance.call("ne", &[Value::F64((1.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 597 +fn c585_l597_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c585_l597_action_invoke"); + let result = instance.call("ne", &[Value::F64((-1.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 598 +fn c586_l598_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c586_l598_action_invoke"); + let result = instance.call("ne", &[Value::F64((-1.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 599 +fn c587_l599_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c587_l599_action_invoke"); + let result = instance.call("ne", &[Value::F64((1.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 600 +fn c588_l600_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c588_l600_action_invoke"); + let result = instance.call("ne", &[Value::F64((1.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 601 +fn c589_l601_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c589_l601_action_invoke"); + let result = instance.call("ne", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 602 +fn c590_l602_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c590_l602_action_invoke"); + let result = instance.call("ne", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 603 +fn c591_l603_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c591_l603_action_invoke"); + let result = instance.call("ne", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 604 +fn c592_l604_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c592_l604_action_invoke"); + let result = instance.call("ne", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 605 +fn c593_l605_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c593_l605_action_invoke"); + let result = instance.call("ne", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 606 +fn c594_l606_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c594_l606_action_invoke"); + let result = instance.call("ne", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 607 +fn c595_l607_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c595_l607_action_invoke"); + let result = instance.call("ne", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 608 +fn c596_l608_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c596_l608_action_invoke"); + let result = instance.call("ne", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 609 +fn c597_l609_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c597_l609_action_invoke"); + let result = instance.call("ne", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 610 +fn c598_l610_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c598_l610_action_invoke"); + let result = instance.call("ne", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 611 +fn c599_l611_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c599_l611_action_invoke"); + let result = instance.call("ne", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 612 +fn c600_l612_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c600_l612_action_invoke"); + let result = instance.call("ne", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 613 +fn c601_l613_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c601_l613_action_invoke"); + let result = instance.call("ne", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 614 +fn c602_l614_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c602_l614_action_invoke"); + let result = instance.call("ne", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 615 +fn c603_l615_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c603_l615_action_invoke"); + let result = instance.call("ne", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 616 +fn c604_l616_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c604_l616_action_invoke"); + let result = instance.call("ne", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 617 +fn c605_l617_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c605_l617_action_invoke"); + let result = instance.call("ne", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 618 +fn c606_l618_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c606_l618_action_invoke"); + let result = instance.call("ne", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 619 +fn c607_l619_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c607_l619_action_invoke"); + let result = instance.call("ne", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 620 +fn c608_l620_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c608_l620_action_invoke"); + let result = instance.call("ne", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 621 +fn c609_l621_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c609_l621_action_invoke"); + let result = instance.call("ne", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 622 +fn c610_l622_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c610_l622_action_invoke"); + let result = instance.call("ne", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 623 +fn c611_l623_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c611_l623_action_invoke"); + let result = instance.call("ne", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 624 +fn c612_l624_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c612_l624_action_invoke"); + let result = instance.call("ne", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 625 +fn c613_l625_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c613_l625_action_invoke"); + let result = instance.call("ne", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 626 +fn c614_l626_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c614_l626_action_invoke"); + let result = instance.call("ne", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 627 +fn c615_l627_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c615_l627_action_invoke"); + let result = instance.call("ne", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 628 +fn c616_l628_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c616_l628_action_invoke"); + let result = instance.call("ne", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 629 +fn c617_l629_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c617_l629_action_invoke"); + let result = instance.call("ne", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 630 +fn c618_l630_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c618_l630_action_invoke"); + let result = instance.call("ne", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 631 +fn c619_l631_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c619_l631_action_invoke"); + let result = instance.call("ne", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 632 +fn c620_l632_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c620_l632_action_invoke"); + let result = instance.call("ne", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 633 +fn c621_l633_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c621_l633_action_invoke"); + let result = instance.call("ne", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 634 +fn c622_l634_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c622_l634_action_invoke"); + let result = instance.call("ne", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 635 +fn c623_l635_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c623_l635_action_invoke"); + let result = instance.call("ne", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 636 +fn c624_l636_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c624_l636_action_invoke"); + let result = instance.call("ne", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 637 +fn c625_l637_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c625_l637_action_invoke"); + let result = instance.call("ne", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 638 +fn c626_l638_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c626_l638_action_invoke"); + let result = instance.call("ne", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 639 +fn c627_l639_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c627_l639_action_invoke"); + let result = instance.call("ne", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 640 +fn c628_l640_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c628_l640_action_invoke"); + let result = instance.call("ne", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 641 +fn c629_l641_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c629_l641_action_invoke"); + let result = instance.call("ne", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 642 +fn c630_l642_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c630_l642_action_invoke"); + let result = instance.call("ne", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 643 +fn c631_l643_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c631_l643_action_invoke"); + let result = instance.call("ne", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 644 +fn c632_l644_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c632_l644_action_invoke"); + let result = instance.call("ne", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 645 +fn c633_l645_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c633_l645_action_invoke"); + let result = instance.call("ne", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 646 +fn c634_l646_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c634_l646_action_invoke"); + let result = instance.call("ne", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 647 +fn c635_l647_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c635_l647_action_invoke"); + let result = instance.call("ne", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 648 +fn c636_l648_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c636_l648_action_invoke"); + let result = instance.call("ne", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 649 +fn c637_l649_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c637_l649_action_invoke"); + let result = instance.call("ne", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 650 +fn c638_l650_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c638_l650_action_invoke"); + let result = instance.call("ne", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 651 +fn c639_l651_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c639_l651_action_invoke"); + let result = instance.call("ne", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 652 +fn c640_l652_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c640_l652_action_invoke"); + let result = instance.call("ne", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 653 +fn c641_l653_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c641_l653_action_invoke"); + let result = instance.call("ne", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 654 +fn c642_l654_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c642_l654_action_invoke"); + let result = instance.call("ne", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 655 +fn c643_l655_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c643_l655_action_invoke"); + let result = instance.call("ne", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 656 +fn c644_l656_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c644_l656_action_invoke"); + let result = instance.call("ne", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 657 +fn c645_l657_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c645_l657_action_invoke"); + let result = instance.call("ne", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 658 +fn c646_l658_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c646_l658_action_invoke"); + let result = instance.call("ne", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 659 +fn c647_l659_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c647_l659_action_invoke"); + let result = instance.call("ne", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 660 +fn c648_l660_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c648_l660_action_invoke"); + let result = instance.call("ne", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 661 +fn c649_l661_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c649_l661_action_invoke"); + let result = instance.call("ne", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 662 +fn c650_l662_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c650_l662_action_invoke"); + let result = instance.call("ne", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 663 +fn c651_l663_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c651_l663_action_invoke"); + let result = instance.call("ne", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 664 +fn c652_l664_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c652_l664_action_invoke"); + let result = instance.call("ne", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 665 +fn c653_l665_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c653_l665_action_invoke"); + let result = instance.call("ne", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 666 +fn c654_l666_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c654_l666_action_invoke"); + let result = instance.call("ne", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 667 +fn c655_l667_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c655_l667_action_invoke"); + let result = instance.call("ne", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 668 +fn c656_l668_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c656_l668_action_invoke"); + let result = instance.call("ne", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 669 +fn c657_l669_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c657_l669_action_invoke"); + let result = instance.call("ne", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 670 +fn c658_l670_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c658_l670_action_invoke"); + let result = instance.call("ne", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 671 +fn c659_l671_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c659_l671_action_invoke"); + let result = instance.call("ne", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 672 +fn c660_l672_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c660_l672_action_invoke"); + let result = instance.call("ne", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 673 +fn c661_l673_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c661_l673_action_invoke"); + let result = instance.call("ne", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 674 +fn c662_l674_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c662_l674_action_invoke"); + let result = instance.call("ne", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 675 +fn c663_l675_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c663_l675_action_invoke"); + let result = instance.call("ne", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 676 +fn c664_l676_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c664_l676_action_invoke"); + let result = instance.call("ne", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 677 +fn c665_l677_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c665_l677_action_invoke"); + let result = instance.call("ne", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 678 +fn c666_l678_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c666_l678_action_invoke"); + let result = instance.call("ne", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 679 +fn c667_l679_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c667_l679_action_invoke"); + let result = instance.call("ne", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 680 +fn c668_l680_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c668_l680_action_invoke"); + let result = instance.call("ne", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 681 +fn c669_l681_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c669_l681_action_invoke"); + let result = instance.call("ne", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 682 +fn c670_l682_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c670_l682_action_invoke"); + let result = instance.call("ne", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 683 +fn c671_l683_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c671_l683_action_invoke"); + let result = instance.call("ne", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 684 +fn c672_l684_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c672_l684_action_invoke"); + let result = instance.call("ne", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 685 +fn c673_l685_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c673_l685_action_invoke"); + let result = instance.call("ne", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 686 +fn c674_l686_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c674_l686_action_invoke"); + let result = instance.call("ne", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 687 +fn c675_l687_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c675_l687_action_invoke"); + let result = instance.call("ne", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 688 +fn c676_l688_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c676_l688_action_invoke"); + let result = instance.call("ne", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 689 +fn c677_l689_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c677_l689_action_invoke"); + let result = instance.call("ne", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 690 +fn c678_l690_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c678_l690_action_invoke"); + let result = instance.call("ne", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 691 +fn c679_l691_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c679_l691_action_invoke"); + let result = instance.call("ne", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 692 +fn c680_l692_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c680_l692_action_invoke"); + let result = instance.call("ne", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 693 +fn c681_l693_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c681_l693_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 694 +fn c682_l694_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c682_l694_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 695 +fn c683_l695_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c683_l695_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 696 +fn c684_l696_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c684_l696_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 697 +fn c685_l697_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c685_l697_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 698 +fn c686_l698_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c686_l698_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 699 +fn c687_l699_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c687_l699_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 700 +fn c688_l700_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c688_l700_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 701 +fn c689_l701_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c689_l701_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 702 +fn c690_l702_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c690_l702_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 703 +fn c691_l703_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c691_l703_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 704 +fn c692_l704_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c692_l704_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 705 +fn c693_l705_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c693_l705_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 706 +fn c694_l706_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c694_l706_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 707 +fn c695_l707_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c695_l707_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 708 +fn c696_l708_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c696_l708_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 709 +fn c697_l709_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c697_l709_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 710 +fn c698_l710_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c698_l710_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 711 +fn c699_l711_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c699_l711_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 712 +fn c700_l712_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c700_l712_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 713 +fn c701_l713_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c701_l713_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 714 +fn c702_l714_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c702_l714_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 715 +fn c703_l715_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c703_l715_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 716 +fn c704_l716_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c704_l716_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 717 +fn c705_l717_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c705_l717_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 718 +fn c706_l718_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c706_l718_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 719 +fn c707_l719_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c707_l719_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 720 +fn c708_l720_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c708_l720_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 721 +fn c709_l721_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c709_l721_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 722 +fn c710_l722_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c710_l722_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 723 +fn c711_l723_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c711_l723_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 724 +fn c712_l724_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c712_l724_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 725 +fn c713_l725_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c713_l725_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 726 +fn c714_l726_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c714_l726_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 727 +fn c715_l727_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c715_l727_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 728 +fn c716_l728_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c716_l728_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 729 +fn c717_l729_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c717_l729_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 730 +fn c718_l730_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c718_l730_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 731 +fn c719_l731_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c719_l731_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 732 +fn c720_l732_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c720_l732_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 733 +fn c721_l733_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c721_l733_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 734 +fn c722_l734_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c722_l734_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 735 +fn c723_l735_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c723_l735_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 736 +fn c724_l736_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c724_l736_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 737 +fn c725_l737_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c725_l737_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 738 +fn c726_l738_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c726_l738_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 739 +fn c727_l739_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c727_l739_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 740 +fn c728_l740_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c728_l740_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 741 +fn c729_l741_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c729_l741_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 742 +fn c730_l742_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c730_l742_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 743 +fn c731_l743_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c731_l743_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 744 +fn c732_l744_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c732_l744_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 745 +fn c733_l745_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c733_l745_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 746 +fn c734_l746_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c734_l746_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 747 +fn c735_l747_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c735_l747_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 748 +fn c736_l748_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c736_l748_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 749 +fn c737_l749_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c737_l749_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 750 +fn c738_l750_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c738_l750_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 751 +fn c739_l751_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c739_l751_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 752 +fn c740_l752_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c740_l752_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 753 +fn c741_l753_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c741_l753_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 754 +fn c742_l754_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c742_l754_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 755 +fn c743_l755_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c743_l755_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 756 +fn c744_l756_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c744_l756_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 757 +fn c745_l757_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c745_l757_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 758 +fn c746_l758_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c746_l758_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 759 +fn c747_l759_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c747_l759_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 760 +fn c748_l760_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c748_l760_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 761 +fn c749_l761_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c749_l761_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 762 +fn c750_l762_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c750_l762_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 763 +fn c751_l763_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c751_l763_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 764 +fn c752_l764_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c752_l764_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 765 +fn c753_l765_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c753_l765_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 766 +fn c754_l766_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c754_l766_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 767 +fn c755_l767_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c755_l767_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 768 +fn c756_l768_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c756_l768_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 769 +fn c757_l769_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c757_l769_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 770 +fn c758_l770_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c758_l770_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 771 +fn c759_l771_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c759_l771_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 772 +fn c760_l772_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c760_l772_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 773 +fn c761_l773_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c761_l773_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 774 +fn c762_l774_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c762_l774_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 775 +fn c763_l775_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c763_l775_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 776 +fn c764_l776_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c764_l776_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 777 +fn c765_l777_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c765_l777_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 778 +fn c766_l778_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c766_l778_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 779 +fn c767_l779_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c767_l779_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 780 +fn c768_l780_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c768_l780_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 781 +fn c769_l781_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c769_l781_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 782 +fn c770_l782_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c770_l782_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 783 +fn c771_l783_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c771_l783_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 784 +fn c772_l784_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c772_l784_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 785 +fn c773_l785_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c773_l785_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 786 +fn c774_l786_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c774_l786_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 787 +fn c775_l787_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c775_l787_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 788 +fn c776_l788_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c776_l788_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 789 +fn c777_l789_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c777_l789_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 790 +fn c778_l790_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c778_l790_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 791 +fn c779_l791_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c779_l791_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 792 +fn c780_l792_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c780_l792_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 793 +fn c781_l793_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c781_l793_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 794 +fn c782_l794_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c782_l794_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 795 +fn c783_l795_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c783_l795_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 796 +fn c784_l796_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c784_l796_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 797 +fn c785_l797_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c785_l797_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 798 +fn c786_l798_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c786_l798_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 799 +fn c787_l799_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c787_l799_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 800 +fn c788_l800_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c788_l800_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 801 +fn c789_l801_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c789_l801_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 802 +fn c790_l802_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c790_l802_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 803 +fn c791_l803_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c791_l803_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 804 +fn c792_l804_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c792_l804_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 805 +fn c793_l805_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c793_l805_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 806 +fn c794_l806_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c794_l806_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 807 +fn c795_l807_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c795_l807_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 808 +fn c796_l808_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c796_l808_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 809 +fn c797_l809_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c797_l809_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 810 +fn c798_l810_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c798_l810_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 811 +fn c799_l811_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c799_l811_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 812 +fn c800_l812_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c800_l812_action_invoke"); + let result = instance.call("ne", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 813 +fn c801_l813_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c801_l813_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 814 +fn c802_l814_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c802_l814_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 815 +fn c803_l815_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c803_l815_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 816 +fn c804_l816_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c804_l816_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 817 +fn c805_l817_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c805_l817_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 818 +fn c806_l818_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c806_l818_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 819 +fn c807_l819_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c807_l819_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 820 +fn c808_l820_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c808_l820_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 821 +fn c809_l821_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c809_l821_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 822 +fn c810_l822_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c810_l822_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 823 +fn c811_l823_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c811_l823_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 824 +fn c812_l824_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c812_l824_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 825 +fn c813_l825_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c813_l825_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 826 +fn c814_l826_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c814_l826_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 827 +fn c815_l827_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c815_l827_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 828 +fn c816_l828_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c816_l828_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 829 +fn c817_l829_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c817_l829_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 830 +fn c818_l830_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c818_l830_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 831 +fn c819_l831_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c819_l831_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 832 +fn c820_l832_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c820_l832_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 833 +fn c821_l833_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c821_l833_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 834 +fn c822_l834_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c822_l834_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 835 +fn c823_l835_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c823_l835_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 836 +fn c824_l836_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c824_l836_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 837 +fn c825_l837_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c825_l837_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 838 +fn c826_l838_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c826_l838_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 839 +fn c827_l839_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c827_l839_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 840 +fn c828_l840_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c828_l840_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 841 +fn c829_l841_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c829_l841_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 842 +fn c830_l842_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c830_l842_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 843 +fn c831_l843_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c831_l843_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 844 +fn c832_l844_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c832_l844_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 845 +fn c833_l845_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c833_l845_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 846 +fn c834_l846_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c834_l846_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 847 +fn c835_l847_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c835_l847_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 848 +fn c836_l848_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c836_l848_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 849 +fn c837_l849_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c837_l849_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 850 +fn c838_l850_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c838_l850_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 851 +fn c839_l851_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c839_l851_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 852 +fn c840_l852_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c840_l852_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 853 +fn c841_l853_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c841_l853_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 854 +fn c842_l854_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c842_l854_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 855 +fn c843_l855_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c843_l855_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 856 +fn c844_l856_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c844_l856_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 857 +fn c845_l857_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c845_l857_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 858 +fn c846_l858_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c846_l858_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 859 +fn c847_l859_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c847_l859_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 860 +fn c848_l860_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c848_l860_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 861 +fn c849_l861_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c849_l861_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 862 +fn c850_l862_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c850_l862_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 863 +fn c851_l863_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c851_l863_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 864 +fn c852_l864_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c852_l864_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 865 +fn c853_l865_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c853_l865_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 866 +fn c854_l866_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c854_l866_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 867 +fn c855_l867_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c855_l867_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 868 +fn c856_l868_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c856_l868_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 869 +fn c857_l869_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c857_l869_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 870 +fn c858_l870_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c858_l870_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 871 +fn c859_l871_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c859_l871_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 872 +fn c860_l872_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c860_l872_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 873 +fn c861_l873_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c861_l873_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 874 +fn c862_l874_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c862_l874_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 875 +fn c863_l875_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c863_l875_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 876 +fn c864_l876_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c864_l876_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 877 +fn c865_l877_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c865_l877_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 878 +fn c866_l878_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c866_l878_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 879 +fn c867_l879_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c867_l879_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 880 +fn c868_l880_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c868_l880_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 881 +fn c869_l881_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c869_l881_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 882 +fn c870_l882_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c870_l882_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 883 +fn c871_l883_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c871_l883_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 884 +fn c872_l884_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c872_l884_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 885 +fn c873_l885_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c873_l885_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 886 +fn c874_l886_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c874_l886_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 887 +fn c875_l887_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c875_l887_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 888 +fn c876_l888_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c876_l888_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 889 +fn c877_l889_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c877_l889_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 890 +fn c878_l890_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c878_l890_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 891 +fn c879_l891_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c879_l891_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 892 +fn c880_l892_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c880_l892_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 893 +fn c881_l893_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c881_l893_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 894 +fn c882_l894_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c882_l894_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 895 +fn c883_l895_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c883_l895_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 896 +fn c884_l896_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c884_l896_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 897 +fn c885_l897_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c885_l897_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 898 +fn c886_l898_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c886_l898_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 899 +fn c887_l899_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c887_l899_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 900 +fn c888_l900_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c888_l900_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 901 +fn c889_l901_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c889_l901_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 902 +fn c890_l902_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c890_l902_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 903 +fn c891_l903_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c891_l903_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 904 +fn c892_l904_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c892_l904_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 905 +fn c893_l905_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c893_l905_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 906 +fn c894_l906_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c894_l906_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 907 +fn c895_l907_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c895_l907_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 908 +fn c896_l908_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c896_l908_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 909 +fn c897_l909_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c897_l909_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 910 +fn c898_l910_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c898_l910_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 911 +fn c899_l911_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c899_l911_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 912 +fn c900_l912_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c900_l912_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 913 +fn c901_l913_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c901_l913_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 914 +fn c902_l914_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c902_l914_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 915 +fn c903_l915_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c903_l915_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 916 +fn c904_l916_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c904_l916_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 917 +fn c905_l917_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c905_l917_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 918 +fn c906_l918_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c906_l918_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 919 +fn c907_l919_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c907_l919_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 920 +fn c908_l920_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c908_l920_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 921 +fn c909_l921_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c909_l921_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 922 +fn c910_l922_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c910_l922_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 923 +fn c911_l923_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c911_l923_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 924 +fn c912_l924_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c912_l924_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 925 +fn c913_l925_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c913_l925_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 926 +fn c914_l926_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c914_l926_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 927 +fn c915_l927_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c915_l927_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 928 +fn c916_l928_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c916_l928_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 929 +fn c917_l929_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c917_l929_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 930 +fn c918_l930_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c918_l930_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 931 +fn c919_l931_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c919_l931_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 932 +fn c920_l932_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c920_l932_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 933 +fn c921_l933_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c921_l933_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 934 +fn c922_l934_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c922_l934_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 935 +fn c923_l935_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c923_l935_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 936 +fn c924_l936_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c924_l936_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.5f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 937 +fn c925_l937_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c925_l937_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 938 +fn c926_l938_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c926_l938_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 939 +fn c927_l939_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c927_l939_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 940 +fn c928_l940_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c928_l940_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 941 +fn c929_l941_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c929_l941_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 942 +fn c930_l942_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c930_l942_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 943 +fn c931_l943_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c931_l943_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 944 +fn c932_l944_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c932_l944_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 945 +fn c933_l945_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c933_l945_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 946 +fn c934_l946_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c934_l946_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 947 +fn c935_l947_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c935_l947_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 948 +fn c936_l948_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c936_l948_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.5f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 949 +fn c937_l949_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c937_l949_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.5f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 950 +fn c938_l950_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c938_l950_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.5f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 951 +fn c939_l951_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c939_l951_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.5f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 952 +fn c940_l952_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c940_l952_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.5f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 953 +fn c941_l953_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c941_l953_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.5f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 954 +fn c942_l954_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c942_l954_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.5f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 955 +fn c943_l955_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c943_l955_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.5f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 956 +fn c944_l956_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c944_l956_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.5f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 957 +fn c945_l957_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c945_l957_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.5f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 958 +fn c946_l958_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c946_l958_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.5f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 959 +fn c947_l959_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c947_l959_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.5f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 960 +fn c948_l960_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c948_l960_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.5f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 961 +fn c949_l961_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c949_l961_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 962 +fn c950_l962_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c950_l962_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 963 +fn c951_l963_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c951_l963_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 964 +fn c952_l964_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c952_l964_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 965 +fn c953_l965_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c953_l965_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 966 +fn c954_l966_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c954_l966_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 967 +fn c955_l967_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c955_l967_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 968 +fn c956_l968_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c956_l968_action_invoke"); + let result = instance.call("lt", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 969 +fn c957_l969_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c957_l969_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 970 +fn c958_l970_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c958_l970_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 971 +fn c959_l971_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c959_l971_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 972 +fn c960_l972_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c960_l972_action_invoke"); + let result = instance.call("lt", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 973 +fn c961_l973_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c961_l973_action_invoke"); + let result = instance.call("lt", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 974 +fn c962_l974_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c962_l974_action_invoke"); + let result = instance.call("lt", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 975 +fn c963_l975_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c963_l975_action_invoke"); + let result = instance.call("lt", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 976 +fn c964_l976_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c964_l976_action_invoke"); + let result = instance.call("lt", &[Value::F64((1.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 977 +fn c965_l977_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c965_l977_action_invoke"); + let result = instance.call("lt", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 978 +fn c966_l978_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c966_l978_action_invoke"); + let result = instance.call("lt", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 979 +fn c967_l979_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c967_l979_action_invoke"); + let result = instance.call("lt", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 980 +fn c968_l980_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c968_l980_action_invoke"); + let result = instance.call("lt", &[Value::F64((1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 981 +fn c969_l981_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c969_l981_action_invoke"); + let result = instance.call("lt", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 982 +fn c970_l982_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c970_l982_action_invoke"); + let result = instance.call("lt", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 983 +fn c971_l983_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c971_l983_action_invoke"); + let result = instance.call("lt", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 984 +fn c972_l984_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c972_l984_action_invoke"); + let result = instance.call("lt", &[Value::F64((1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 985 +fn c973_l985_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c973_l985_action_invoke"); + let result = instance.call("lt", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 986 +fn c974_l986_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c974_l986_action_invoke"); + let result = instance.call("lt", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 987 +fn c975_l987_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c975_l987_action_invoke"); + let result = instance.call("lt", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 988 +fn c976_l988_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c976_l988_action_invoke"); + let result = instance.call("lt", &[Value::F64((1.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 989 +fn c977_l989_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c977_l989_action_invoke"); + let result = instance.call("lt", &[Value::F64((-1.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 990 +fn c978_l990_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c978_l990_action_invoke"); + let result = instance.call("lt", &[Value::F64((-1.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 991 +fn c979_l991_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c979_l991_action_invoke"); + let result = instance.call("lt", &[Value::F64((1.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 992 +fn c980_l992_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c980_l992_action_invoke"); + let result = instance.call("lt", &[Value::F64((1.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 993 +fn c981_l993_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c981_l993_action_invoke"); + let result = instance.call("lt", &[Value::F64((-1.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 994 +fn c982_l994_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c982_l994_action_invoke"); + let result = instance.call("lt", &[Value::F64((-1.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 995 +fn c983_l995_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c983_l995_action_invoke"); + let result = instance.call("lt", &[Value::F64((1.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 996 +fn c984_l996_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c984_l996_action_invoke"); + let result = instance.call("lt", &[Value::F64((1.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 997 +fn c985_l997_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c985_l997_action_invoke"); + let result = instance.call("lt", &[Value::F64((-1.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 998 +fn c986_l998_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c986_l998_action_invoke"); + let result = instance.call("lt", &[Value::F64((-1.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 999 +fn c987_l999_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c987_l999_action_invoke"); + let result = instance.call("lt", &[Value::F64((1.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1000 +fn c988_l1000_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c988_l1000_action_invoke"); + let result = instance.call("lt", &[Value::F64((1.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1001 +fn c989_l1001_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c989_l1001_action_invoke"); + let result = instance.call("lt", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1002 +fn c990_l1002_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c990_l1002_action_invoke"); + let result = instance.call("lt", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1003 +fn c991_l1003_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c991_l1003_action_invoke"); + let result = instance.call("lt", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1004 +fn c992_l1004_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c992_l1004_action_invoke"); + let result = instance.call("lt", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1005 +fn c993_l1005_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c993_l1005_action_invoke"); + let result = instance.call("lt", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1006 +fn c994_l1006_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c994_l1006_action_invoke"); + let result = instance.call("lt", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1007 +fn c995_l1007_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c995_l1007_action_invoke"); + let result = instance.call("lt", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1008 +fn c996_l1008_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c996_l1008_action_invoke"); + let result = instance.call("lt", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1009 +fn c997_l1009_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c997_l1009_action_invoke"); + let result = instance.call("lt", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1010 +fn c998_l1010_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c998_l1010_action_invoke"); + let result = instance.call("lt", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1011 +fn c999_l1011_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c999_l1011_action_invoke"); + let result = instance.call("lt", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1012 +fn c1000_l1012_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1000_l1012_action_invoke"); + let result = instance.call("lt", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1013 +fn c1001_l1013_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1001_l1013_action_invoke"); + let result = instance.call("lt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1014 +fn c1002_l1014_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1002_l1014_action_invoke"); + let result = instance.call("lt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1015 +fn c1003_l1015_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1003_l1015_action_invoke"); + let result = instance.call("lt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1016 +fn c1004_l1016_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1004_l1016_action_invoke"); + let result = instance.call("lt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1017 +fn c1005_l1017_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1005_l1017_action_invoke"); + let result = instance.call("lt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1018 +fn c1006_l1018_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1006_l1018_action_invoke"); + let result = instance.call("lt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1019 +fn c1007_l1019_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1007_l1019_action_invoke"); + let result = instance.call("lt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1020 +fn c1008_l1020_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1008_l1020_action_invoke"); + let result = instance.call("lt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1021 +fn c1009_l1021_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1009_l1021_action_invoke"); + let result = instance.call("lt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1022 +fn c1010_l1022_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1010_l1022_action_invoke"); + let result = instance.call("lt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1023 +fn c1011_l1023_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1011_l1023_action_invoke"); + let result = instance.call("lt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1024 +fn c1012_l1024_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1012_l1024_action_invoke"); + let result = instance.call("lt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1025 +fn c1013_l1025_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1013_l1025_action_invoke"); + let result = instance.call("lt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1026 +fn c1014_l1026_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1014_l1026_action_invoke"); + let result = instance.call("lt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1027 +fn c1015_l1027_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1015_l1027_action_invoke"); + let result = instance.call("lt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1028 +fn c1016_l1028_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1016_l1028_action_invoke"); + let result = instance.call("lt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1029 +fn c1017_l1029_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1017_l1029_action_invoke"); + let result = instance.call("lt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1030 +fn c1018_l1030_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1018_l1030_action_invoke"); + let result = instance.call("lt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1031 +fn c1019_l1031_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1019_l1031_action_invoke"); + let result = instance.call("lt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1032 +fn c1020_l1032_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1020_l1032_action_invoke"); + let result = instance.call("lt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1033 +fn c1021_l1033_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1021_l1033_action_invoke"); + let result = instance.call("lt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1034 +fn c1022_l1034_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1022_l1034_action_invoke"); + let result = instance.call("lt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1035 +fn c1023_l1035_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1023_l1035_action_invoke"); + let result = instance.call("lt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1036 +fn c1024_l1036_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1024_l1036_action_invoke"); + let result = instance.call("lt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1037 +fn c1025_l1037_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1025_l1037_action_invoke"); + let result = instance.call("lt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1038 +fn c1026_l1038_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1026_l1038_action_invoke"); + let result = instance.call("lt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1039 +fn c1027_l1039_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1027_l1039_action_invoke"); + let result = instance.call("lt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1040 +fn c1028_l1040_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1028_l1040_action_invoke"); + let result = instance.call("lt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1041 +fn c1029_l1041_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1029_l1041_action_invoke"); + let result = instance.call("lt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1042 +fn c1030_l1042_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1030_l1042_action_invoke"); + let result = instance.call("lt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1043 +fn c1031_l1043_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1031_l1043_action_invoke"); + let result = instance.call("lt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1044 +fn c1032_l1044_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1032_l1044_action_invoke"); + let result = instance.call("lt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1045 +fn c1033_l1045_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1033_l1045_action_invoke"); + let result = instance.call("lt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1046 +fn c1034_l1046_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1034_l1046_action_invoke"); + let result = instance.call("lt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1047 +fn c1035_l1047_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1035_l1047_action_invoke"); + let result = instance.call("lt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1048 +fn c1036_l1048_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1036_l1048_action_invoke"); + let result = instance.call("lt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1049 +fn c1037_l1049_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1037_l1049_action_invoke"); + let result = instance.call("lt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1050 +fn c1038_l1050_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1038_l1050_action_invoke"); + let result = instance.call("lt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1051 +fn c1039_l1051_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1039_l1051_action_invoke"); + let result = instance.call("lt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1052 +fn c1040_l1052_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1040_l1052_action_invoke"); + let result = instance.call("lt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1053 +fn c1041_l1053_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1041_l1053_action_invoke"); + let result = instance.call("lt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1054 +fn c1042_l1054_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1042_l1054_action_invoke"); + let result = instance.call("lt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1055 +fn c1043_l1055_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1043_l1055_action_invoke"); + let result = instance.call("lt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1056 +fn c1044_l1056_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1044_l1056_action_invoke"); + let result = instance.call("lt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1057 +fn c1045_l1057_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1045_l1057_action_invoke"); + let result = instance.call("lt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1058 +fn c1046_l1058_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1046_l1058_action_invoke"); + let result = instance.call("lt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1059 +fn c1047_l1059_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1047_l1059_action_invoke"); + let result = instance.call("lt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1060 +fn c1048_l1060_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1048_l1060_action_invoke"); + let result = instance.call("lt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1061 +fn c1049_l1061_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1049_l1061_action_invoke"); + let result = instance.call("lt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1062 +fn c1050_l1062_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1050_l1062_action_invoke"); + let result = instance.call("lt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1063 +fn c1051_l1063_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1051_l1063_action_invoke"); + let result = instance.call("lt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1064 +fn c1052_l1064_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1052_l1064_action_invoke"); + let result = instance.call("lt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1065 +fn c1053_l1065_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1053_l1065_action_invoke"); + let result = instance.call("lt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1066 +fn c1054_l1066_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1054_l1066_action_invoke"); + let result = instance.call("lt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1067 +fn c1055_l1067_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1055_l1067_action_invoke"); + let result = instance.call("lt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1068 +fn c1056_l1068_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1056_l1068_action_invoke"); + let result = instance.call("lt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1069 +fn c1057_l1069_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1057_l1069_action_invoke"); + let result = instance.call("lt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1070 +fn c1058_l1070_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1058_l1070_action_invoke"); + let result = instance.call("lt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1071 +fn c1059_l1071_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1059_l1071_action_invoke"); + let result = instance.call("lt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1072 +fn c1060_l1072_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1060_l1072_action_invoke"); + let result = instance.call("lt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1073 +fn c1061_l1073_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1061_l1073_action_invoke"); + let result = instance.call("lt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1074 +fn c1062_l1074_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1062_l1074_action_invoke"); + let result = instance.call("lt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1075 +fn c1063_l1075_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1063_l1075_action_invoke"); + let result = instance.call("lt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1076 +fn c1064_l1076_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1064_l1076_action_invoke"); + let result = instance.call("lt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1077 +fn c1065_l1077_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1065_l1077_action_invoke"); + let result = instance.call("lt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1078 +fn c1066_l1078_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1066_l1078_action_invoke"); + let result = instance.call("lt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1079 +fn c1067_l1079_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1067_l1079_action_invoke"); + let result = instance.call("lt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1080 +fn c1068_l1080_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1068_l1080_action_invoke"); + let result = instance.call("lt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1081 +fn c1069_l1081_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1069_l1081_action_invoke"); + let result = instance.call("lt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1082 +fn c1070_l1082_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1070_l1082_action_invoke"); + let result = instance.call("lt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1083 +fn c1071_l1083_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1071_l1083_action_invoke"); + let result = instance.call("lt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1084 +fn c1072_l1084_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1072_l1084_action_invoke"); + let result = instance.call("lt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1085 +fn c1073_l1085_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1073_l1085_action_invoke"); + let result = instance.call("lt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1086 +fn c1074_l1086_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1074_l1086_action_invoke"); + let result = instance.call("lt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1087 +fn c1075_l1087_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1075_l1087_action_invoke"); + let result = instance.call("lt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1088 +fn c1076_l1088_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1076_l1088_action_invoke"); + let result = instance.call("lt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1089 +fn c1077_l1089_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1077_l1089_action_invoke"); + let result = instance.call("lt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1090 +fn c1078_l1090_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1078_l1090_action_invoke"); + let result = instance.call("lt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1091 +fn c1079_l1091_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1079_l1091_action_invoke"); + let result = instance.call("lt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1092 +fn c1080_l1092_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1080_l1092_action_invoke"); + let result = instance.call("lt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1093 +fn c1081_l1093_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1081_l1093_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1094 +fn c1082_l1094_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1082_l1094_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1095 +fn c1083_l1095_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1083_l1095_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1096 +fn c1084_l1096_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1084_l1096_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1097 +fn c1085_l1097_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1085_l1097_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1098 +fn c1086_l1098_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1086_l1098_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1099 +fn c1087_l1099_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1087_l1099_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1100 +fn c1088_l1100_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1088_l1100_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1101 +fn c1089_l1101_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1089_l1101_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1102 +fn c1090_l1102_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1090_l1102_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1103 +fn c1091_l1103_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1091_l1103_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1104 +fn c1092_l1104_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1092_l1104_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1105 +fn c1093_l1105_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1093_l1105_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1106 +fn c1094_l1106_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1094_l1106_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1107 +fn c1095_l1107_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1095_l1107_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1108 +fn c1096_l1108_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1096_l1108_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1109 +fn c1097_l1109_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1097_l1109_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1110 +fn c1098_l1110_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1098_l1110_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1111 +fn c1099_l1111_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1099_l1111_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1112 +fn c1100_l1112_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1100_l1112_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1113 +fn c1101_l1113_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1101_l1113_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1114 +fn c1102_l1114_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1102_l1114_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1115 +fn c1103_l1115_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1103_l1115_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1116 +fn c1104_l1116_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1104_l1116_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1117 +fn c1105_l1117_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1105_l1117_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1118 +fn c1106_l1118_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1106_l1118_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1119 +fn c1107_l1119_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1107_l1119_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1120 +fn c1108_l1120_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1108_l1120_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1121 +fn c1109_l1121_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1109_l1121_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1122 +fn c1110_l1122_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1110_l1122_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1123 +fn c1111_l1123_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1111_l1123_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1124 +fn c1112_l1124_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1112_l1124_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1125 +fn c1113_l1125_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1113_l1125_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1126 +fn c1114_l1126_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1114_l1126_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1127 +fn c1115_l1127_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1115_l1127_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1128 +fn c1116_l1128_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1116_l1128_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1129 +fn c1117_l1129_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1117_l1129_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1130 +fn c1118_l1130_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1118_l1130_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1131 +fn c1119_l1131_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1119_l1131_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1132 +fn c1120_l1132_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1120_l1132_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1133 +fn c1121_l1133_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1121_l1133_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1134 +fn c1122_l1134_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1122_l1134_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1135 +fn c1123_l1135_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1123_l1135_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1136 +fn c1124_l1136_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1124_l1136_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1137 +fn c1125_l1137_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1125_l1137_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1138 +fn c1126_l1138_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1126_l1138_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1139 +fn c1127_l1139_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1127_l1139_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1140 +fn c1128_l1140_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1128_l1140_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1141 +fn c1129_l1141_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1129_l1141_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1142 +fn c1130_l1142_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1130_l1142_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1143 +fn c1131_l1143_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1131_l1143_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1144 +fn c1132_l1144_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1132_l1144_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1145 +fn c1133_l1145_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1133_l1145_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1146 +fn c1134_l1146_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1134_l1146_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1147 +fn c1135_l1147_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1135_l1147_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1148 +fn c1136_l1148_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1136_l1148_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1149 +fn c1137_l1149_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1137_l1149_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1150 +fn c1138_l1150_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1138_l1150_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1151 +fn c1139_l1151_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1139_l1151_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1152 +fn c1140_l1152_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1140_l1152_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1153 +fn c1141_l1153_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1141_l1153_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1154 +fn c1142_l1154_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1142_l1154_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1155 +fn c1143_l1155_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1143_l1155_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1156 +fn c1144_l1156_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1144_l1156_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1157 +fn c1145_l1157_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1145_l1157_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1158 +fn c1146_l1158_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1146_l1158_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1159 +fn c1147_l1159_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1147_l1159_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1160 +fn c1148_l1160_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1148_l1160_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1161 +fn c1149_l1161_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1149_l1161_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1162 +fn c1150_l1162_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1150_l1162_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1163 +fn c1151_l1163_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1151_l1163_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1164 +fn c1152_l1164_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1152_l1164_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1165 +fn c1153_l1165_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1153_l1165_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1166 +fn c1154_l1166_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1154_l1166_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1167 +fn c1155_l1167_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1155_l1167_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1168 +fn c1156_l1168_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1156_l1168_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1169 +fn c1157_l1169_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1157_l1169_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1170 +fn c1158_l1170_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1158_l1170_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1171 +fn c1159_l1171_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1159_l1171_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1172 +fn c1160_l1172_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1160_l1172_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1173 +fn c1161_l1173_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1161_l1173_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1174 +fn c1162_l1174_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1162_l1174_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1175 +fn c1163_l1175_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1163_l1175_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1176 +fn c1164_l1176_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1164_l1176_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1177 +fn c1165_l1177_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1165_l1177_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1178 +fn c1166_l1178_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1166_l1178_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1179 +fn c1167_l1179_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1167_l1179_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1180 +fn c1168_l1180_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1168_l1180_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1181 +fn c1169_l1181_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1169_l1181_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1182 +fn c1170_l1182_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1170_l1182_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1183 +fn c1171_l1183_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1171_l1183_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1184 +fn c1172_l1184_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1172_l1184_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1185 +fn c1173_l1185_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1173_l1185_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1186 +fn c1174_l1186_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1174_l1186_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1187 +fn c1175_l1187_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1175_l1187_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1188 +fn c1176_l1188_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1176_l1188_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1189 +fn c1177_l1189_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1177_l1189_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1190 +fn c1178_l1190_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1178_l1190_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1191 +fn c1179_l1191_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1179_l1191_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1192 +fn c1180_l1192_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1180_l1192_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1193 +fn c1181_l1193_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1181_l1193_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1194 +fn c1182_l1194_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1182_l1194_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1195 +fn c1183_l1195_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1183_l1195_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1196 +fn c1184_l1196_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1184_l1196_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1197 +fn c1185_l1197_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1185_l1197_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1198 +fn c1186_l1198_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1186_l1198_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1199 +fn c1187_l1199_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1187_l1199_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1200 +fn c1188_l1200_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1188_l1200_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1201 +fn c1189_l1201_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1189_l1201_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1202 +fn c1190_l1202_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1190_l1202_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1203 +fn c1191_l1203_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1191_l1203_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1204 +fn c1192_l1204_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1192_l1204_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1205 +fn c1193_l1205_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1193_l1205_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1206 +fn c1194_l1206_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1194_l1206_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1207 +fn c1195_l1207_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1195_l1207_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1208 +fn c1196_l1208_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1196_l1208_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1209 +fn c1197_l1209_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1197_l1209_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1210 +fn c1198_l1210_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1198_l1210_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1211 +fn c1199_l1211_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1199_l1211_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1212 +fn c1200_l1212_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1200_l1212_action_invoke"); + let result = instance.call("lt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1213 +fn c1201_l1213_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1201_l1213_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1214 +fn c1202_l1214_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1202_l1214_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1215 +fn c1203_l1215_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1203_l1215_action_invoke"); + let result = instance.call("le", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1216 +fn c1204_l1216_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1204_l1216_action_invoke"); + let result = instance.call("le", &[Value::F64((0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1217 +fn c1205_l1217_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1205_l1217_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1218 +fn c1206_l1218_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1206_l1218_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1219 +fn c1207_l1219_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1207_l1219_action_invoke"); + let result = instance.call("le", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1220 +fn c1208_l1220_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1208_l1220_action_invoke"); + let result = instance.call("le", &[Value::F64((0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1221 +fn c1209_l1221_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1209_l1221_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1222 +fn c1210_l1222_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1210_l1222_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1223 +fn c1211_l1223_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1211_l1223_action_invoke"); + let result = instance.call("le", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1224 +fn c1212_l1224_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1212_l1224_action_invoke"); + let result = instance.call("le", &[Value::F64((0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1225 +fn c1213_l1225_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1213_l1225_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1226 +fn c1214_l1226_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1214_l1226_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1227 +fn c1215_l1227_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1215_l1227_action_invoke"); + let result = instance.call("le", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1228 +fn c1216_l1228_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1216_l1228_action_invoke"); + let result = instance.call("le", &[Value::F64((0.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1229 +fn c1217_l1229_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1217_l1229_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1230 +fn c1218_l1230_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1218_l1230_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1231 +fn c1219_l1231_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1219_l1231_action_invoke"); + let result = instance.call("le", &[Value::F64((0.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1232 +fn c1220_l1232_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1220_l1232_action_invoke"); + let result = instance.call("le", &[Value::F64((0.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1233 +fn c1221_l1233_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1221_l1233_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1234 +fn c1222_l1234_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1222_l1234_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1235 +fn c1223_l1235_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1223_l1235_action_invoke"); + let result = instance.call("le", &[Value::F64((0.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1236 +fn c1224_l1236_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1224_l1236_action_invoke"); + let result = instance.call("le", &[Value::F64((0.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1237 +fn c1225_l1237_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1225_l1237_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1238 +fn c1226_l1238_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1226_l1238_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1239 +fn c1227_l1239_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1227_l1239_action_invoke"); + let result = instance.call("le", &[Value::F64((0.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1240 +fn c1228_l1240_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1228_l1240_action_invoke"); + let result = instance.call("le", &[Value::F64((0.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1241 +fn c1229_l1241_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1229_l1241_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1242 +fn c1230_l1242_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1230_l1242_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1243 +fn c1231_l1243_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1231_l1243_action_invoke"); + let result = instance.call("le", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1244 +fn c1232_l1244_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1232_l1244_action_invoke"); + let result = instance.call("le", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1245 +fn c1233_l1245_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1233_l1245_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1246 +fn c1234_l1246_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1234_l1246_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1247 +fn c1235_l1247_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1235_l1247_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1248 +fn c1236_l1248_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1236_l1248_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1249 +fn c1237_l1249_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1237_l1249_action_invoke"); + let result = instance.call("le", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1250 +fn c1238_l1250_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1238_l1250_action_invoke"); + let result = instance.call("le", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1251 +fn c1239_l1251_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1239_l1251_action_invoke"); + let result = instance.call("le", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1252 +fn c1240_l1252_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1240_l1252_action_invoke"); + let result = instance.call("le", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1253 +fn c1241_l1253_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1241_l1253_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1254 +fn c1242_l1254_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1242_l1254_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1255 +fn c1243_l1255_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1243_l1255_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1256 +fn c1244_l1256_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1244_l1256_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1257 +fn c1245_l1257_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1245_l1257_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1258 +fn c1246_l1258_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1246_l1258_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1259 +fn c1247_l1259_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1247_l1259_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1260 +fn c1248_l1260_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1248_l1260_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1261 +fn c1249_l1261_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1249_l1261_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1262 +fn c1250_l1262_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1250_l1262_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1263 +fn c1251_l1263_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1251_l1263_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1264 +fn c1252_l1264_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1252_l1264_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1265 +fn c1253_l1265_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1253_l1265_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1266 +fn c1254_l1266_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1254_l1266_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1267 +fn c1255_l1267_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1255_l1267_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1268 +fn c1256_l1268_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1256_l1268_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1269 +fn c1257_l1269_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1257_l1269_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1270 +fn c1258_l1270_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1258_l1270_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1271 +fn c1259_l1271_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1259_l1271_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1272 +fn c1260_l1272_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1260_l1272_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1273 +fn c1261_l1273_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1261_l1273_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1274 +fn c1262_l1274_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1262_l1274_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1275 +fn c1263_l1275_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1263_l1275_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1276 +fn c1264_l1276_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1264_l1276_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1277 +fn c1265_l1277_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1265_l1277_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1278 +fn c1266_l1278_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1266_l1278_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1279 +fn c1267_l1279_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1267_l1279_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1280 +fn c1268_l1280_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1268_l1280_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1281 +fn c1269_l1281_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1269_l1281_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1282 +fn c1270_l1282_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1270_l1282_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1283 +fn c1271_l1283_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1271_l1283_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1284 +fn c1272_l1284_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1272_l1284_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1285 +fn c1273_l1285_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1273_l1285_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1286 +fn c1274_l1286_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1274_l1286_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1287 +fn c1275_l1287_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1275_l1287_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1288 +fn c1276_l1288_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1276_l1288_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1289 +fn c1277_l1289_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1277_l1289_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1290 +fn c1278_l1290_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1278_l1290_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1291 +fn c1279_l1291_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1279_l1291_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1292 +fn c1280_l1292_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1280_l1292_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1293 +fn c1281_l1293_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1281_l1293_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1294 +fn c1282_l1294_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1282_l1294_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1295 +fn c1283_l1295_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1283_l1295_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1296 +fn c1284_l1296_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1284_l1296_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1297 +fn c1285_l1297_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1285_l1297_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1298 +fn c1286_l1298_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1286_l1298_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1299 +fn c1287_l1299_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1287_l1299_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1300 +fn c1288_l1300_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1288_l1300_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1301 +fn c1289_l1301_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1289_l1301_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1302 +fn c1290_l1302_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1290_l1302_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1303 +fn c1291_l1303_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1291_l1303_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1304 +fn c1292_l1304_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1292_l1304_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1305 +fn c1293_l1305_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1293_l1305_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1306 +fn c1294_l1306_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1294_l1306_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1307 +fn c1295_l1307_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1295_l1307_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1308 +fn c1296_l1308_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1296_l1308_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1309 +fn c1297_l1309_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1297_l1309_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1310 +fn c1298_l1310_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1298_l1310_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1311 +fn c1299_l1311_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1299_l1311_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1312 +fn c1300_l1312_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1300_l1312_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1313 +fn c1301_l1313_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1301_l1313_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1314 +fn c1302_l1314_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1302_l1314_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1315 +fn c1303_l1315_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1303_l1315_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1316 +fn c1304_l1316_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1304_l1316_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1317 +fn c1305_l1317_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1305_l1317_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1318 +fn c1306_l1318_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1306_l1318_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1319 +fn c1307_l1319_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1307_l1319_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1320 +fn c1308_l1320_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1308_l1320_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1321 +fn c1309_l1321_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1309_l1321_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1322 +fn c1310_l1322_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1310_l1322_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1323 +fn c1311_l1323_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1311_l1323_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1324 +fn c1312_l1324_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1312_l1324_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1325 +fn c1313_l1325_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1313_l1325_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1326 +fn c1314_l1326_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1314_l1326_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1327 +fn c1315_l1327_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1315_l1327_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1328 +fn c1316_l1328_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1316_l1328_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1329 +fn c1317_l1329_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1317_l1329_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1330 +fn c1318_l1330_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1318_l1330_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1331 +fn c1319_l1331_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1319_l1331_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1332 +fn c1320_l1332_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1320_l1332_action_invoke"); + let result = instance.call("le", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1333 +fn c1321_l1333_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1321_l1333_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1334 +fn c1322_l1334_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1322_l1334_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1335 +fn c1323_l1335_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1323_l1335_action_invoke"); + let result = instance.call("le", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1336 +fn c1324_l1336_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1324_l1336_action_invoke"); + let result = instance.call("le", &[Value::F64((0.5f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1337 +fn c1325_l1337_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1325_l1337_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1338 +fn c1326_l1338_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1326_l1338_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1339 +fn c1327_l1339_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1327_l1339_action_invoke"); + let result = instance.call("le", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1340 +fn c1328_l1340_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1328_l1340_action_invoke"); + let result = instance.call("le", &[Value::F64((0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1341 +fn c1329_l1341_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1329_l1341_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1342 +fn c1330_l1342_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1330_l1342_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1343 +fn c1331_l1343_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1331_l1343_action_invoke"); + let result = instance.call("le", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1344 +fn c1332_l1344_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1332_l1344_action_invoke"); + let result = instance.call("le", &[Value::F64((0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1345 +fn c1333_l1345_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1333_l1345_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1346 +fn c1334_l1346_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1334_l1346_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1347 +fn c1335_l1347_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1335_l1347_action_invoke"); + let result = instance.call("le", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1348 +fn c1336_l1348_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1336_l1348_action_invoke"); + let result = instance.call("le", &[Value::F64((0.5f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1349 +fn c1337_l1349_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1337_l1349_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.5f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1350 +fn c1338_l1350_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1338_l1350_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.5f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1351 +fn c1339_l1351_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1339_l1351_action_invoke"); + let result = instance.call("le", &[Value::F64((0.5f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1352 +fn c1340_l1352_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1340_l1352_action_invoke"); + let result = instance.call("le", &[Value::F64((0.5f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1353 +fn c1341_l1353_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1341_l1353_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.5f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1354 +fn c1342_l1354_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1342_l1354_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.5f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1355 +fn c1343_l1355_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1343_l1355_action_invoke"); + let result = instance.call("le", &[Value::F64((0.5f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1356 +fn c1344_l1356_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1344_l1356_action_invoke"); + let result = instance.call("le", &[Value::F64((0.5f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1357 +fn c1345_l1357_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1345_l1357_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.5f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1358 +fn c1346_l1358_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1346_l1358_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.5f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1359 +fn c1347_l1359_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1347_l1359_action_invoke"); + let result = instance.call("le", &[Value::F64((0.5f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1360 +fn c1348_l1360_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1348_l1360_action_invoke"); + let result = instance.call("le", &[Value::F64((0.5f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1361 +fn c1349_l1361_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1349_l1361_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1362 +fn c1350_l1362_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1350_l1362_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1363 +fn c1351_l1363_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1351_l1363_action_invoke"); + let result = instance.call("le", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1364 +fn c1352_l1364_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1352_l1364_action_invoke"); + let result = instance.call("le", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1365 +fn c1353_l1365_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1353_l1365_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1366 +fn c1354_l1366_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1354_l1366_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1367 +fn c1355_l1367_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1355_l1367_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1368 +fn c1356_l1368_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1356_l1368_action_invoke"); + let result = instance.call("le", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1369 +fn c1357_l1369_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1357_l1369_action_invoke"); + let result = instance.call("le", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1370 +fn c1358_l1370_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1358_l1370_action_invoke"); + let result = instance.call("le", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1371 +fn c1359_l1371_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1359_l1371_action_invoke"); + let result = instance.call("le", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1372 +fn c1360_l1372_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1360_l1372_action_invoke"); + let result = instance.call("le", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1373 +fn c1361_l1373_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1361_l1373_action_invoke"); + let result = instance.call("le", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1374 +fn c1362_l1374_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1362_l1374_action_invoke"); + let result = instance.call("le", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1375 +fn c1363_l1375_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1363_l1375_action_invoke"); + let result = instance.call("le", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1376 +fn c1364_l1376_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1364_l1376_action_invoke"); + let result = instance.call("le", &[Value::F64((1.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1377 +fn c1365_l1377_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1365_l1377_action_invoke"); + let result = instance.call("le", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1378 +fn c1366_l1378_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1366_l1378_action_invoke"); + let result = instance.call("le", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1379 +fn c1367_l1379_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1367_l1379_action_invoke"); + let result = instance.call("le", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1380 +fn c1368_l1380_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1368_l1380_action_invoke"); + let result = instance.call("le", &[Value::F64((1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1381 +fn c1369_l1381_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1369_l1381_action_invoke"); + let result = instance.call("le", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1382 +fn c1370_l1382_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1370_l1382_action_invoke"); + let result = instance.call("le", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1383 +fn c1371_l1383_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1371_l1383_action_invoke"); + let result = instance.call("le", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1384 +fn c1372_l1384_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1372_l1384_action_invoke"); + let result = instance.call("le", &[Value::F64((1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1385 +fn c1373_l1385_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1373_l1385_action_invoke"); + let result = instance.call("le", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1386 +fn c1374_l1386_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1374_l1386_action_invoke"); + let result = instance.call("le", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1387 +fn c1375_l1387_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1375_l1387_action_invoke"); + let result = instance.call("le", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1388 +fn c1376_l1388_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1376_l1388_action_invoke"); + let result = instance.call("le", &[Value::F64((1.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1389 +fn c1377_l1389_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1377_l1389_action_invoke"); + let result = instance.call("le", &[Value::F64((-1.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1390 +fn c1378_l1390_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1378_l1390_action_invoke"); + let result = instance.call("le", &[Value::F64((-1.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1391 +fn c1379_l1391_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1379_l1391_action_invoke"); + let result = instance.call("le", &[Value::F64((1.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1392 +fn c1380_l1392_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1380_l1392_action_invoke"); + let result = instance.call("le", &[Value::F64((1.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1393 +fn c1381_l1393_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1381_l1393_action_invoke"); + let result = instance.call("le", &[Value::F64((-1.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1394 +fn c1382_l1394_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1382_l1394_action_invoke"); + let result = instance.call("le", &[Value::F64((-1.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1395 +fn c1383_l1395_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1383_l1395_action_invoke"); + let result = instance.call("le", &[Value::F64((1.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1396 +fn c1384_l1396_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1384_l1396_action_invoke"); + let result = instance.call("le", &[Value::F64((1.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1397 +fn c1385_l1397_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1385_l1397_action_invoke"); + let result = instance.call("le", &[Value::F64((-1.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1398 +fn c1386_l1398_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1386_l1398_action_invoke"); + let result = instance.call("le", &[Value::F64((-1.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1399 +fn c1387_l1399_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1387_l1399_action_invoke"); + let result = instance.call("le", &[Value::F64((1.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1400 +fn c1388_l1400_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1388_l1400_action_invoke"); + let result = instance.call("le", &[Value::F64((1.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1401 +fn c1389_l1401_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1389_l1401_action_invoke"); + let result = instance.call("le", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1402 +fn c1390_l1402_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1390_l1402_action_invoke"); + let result = instance.call("le", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1403 +fn c1391_l1403_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1391_l1403_action_invoke"); + let result = instance.call("le", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1404 +fn c1392_l1404_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1392_l1404_action_invoke"); + let result = instance.call("le", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1405 +fn c1393_l1405_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1393_l1405_action_invoke"); + let result = instance.call("le", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1406 +fn c1394_l1406_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1394_l1406_action_invoke"); + let result = instance.call("le", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1407 +fn c1395_l1407_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1395_l1407_action_invoke"); + let result = instance.call("le", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1408 +fn c1396_l1408_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1396_l1408_action_invoke"); + let result = instance.call("le", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1409 +fn c1397_l1409_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1397_l1409_action_invoke"); + let result = instance.call("le", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1410 +fn c1398_l1410_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1398_l1410_action_invoke"); + let result = instance.call("le", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1411 +fn c1399_l1411_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1399_l1411_action_invoke"); + let result = instance.call("le", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1412 +fn c1400_l1412_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1400_l1412_action_invoke"); + let result = instance.call("le", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1413 +fn c1401_l1413_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1401_l1413_action_invoke"); + let result = instance.call("le", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1414 +fn c1402_l1414_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1402_l1414_action_invoke"); + let result = instance.call("le", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1415 +fn c1403_l1415_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1403_l1415_action_invoke"); + let result = instance.call("le", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1416 +fn c1404_l1416_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1404_l1416_action_invoke"); + let result = instance.call("le", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1417 +fn c1405_l1417_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1405_l1417_action_invoke"); + let result = instance.call("le", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1418 +fn c1406_l1418_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1406_l1418_action_invoke"); + let result = instance.call("le", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1419 +fn c1407_l1419_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1407_l1419_action_invoke"); + let result = instance.call("le", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1420 +fn c1408_l1420_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1408_l1420_action_invoke"); + let result = instance.call("le", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1421 +fn c1409_l1421_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1409_l1421_action_invoke"); + let result = instance.call("le", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1422 +fn c1410_l1422_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1410_l1422_action_invoke"); + let result = instance.call("le", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1423 +fn c1411_l1423_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1411_l1423_action_invoke"); + let result = instance.call("le", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1424 +fn c1412_l1424_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1412_l1424_action_invoke"); + let result = instance.call("le", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1425 +fn c1413_l1425_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1413_l1425_action_invoke"); + let result = instance.call("le", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1426 +fn c1414_l1426_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1414_l1426_action_invoke"); + let result = instance.call("le", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1427 +fn c1415_l1427_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1415_l1427_action_invoke"); + let result = instance.call("le", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1428 +fn c1416_l1428_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1416_l1428_action_invoke"); + let result = instance.call("le", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1429 +fn c1417_l1429_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1417_l1429_action_invoke"); + let result = instance.call("le", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1430 +fn c1418_l1430_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1418_l1430_action_invoke"); + let result = instance.call("le", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1431 +fn c1419_l1431_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1419_l1431_action_invoke"); + let result = instance.call("le", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1432 +fn c1420_l1432_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1420_l1432_action_invoke"); + let result = instance.call("le", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1433 +fn c1421_l1433_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1421_l1433_action_invoke"); + let result = instance.call("le", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1434 +fn c1422_l1434_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1422_l1434_action_invoke"); + let result = instance.call("le", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1435 +fn c1423_l1435_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1423_l1435_action_invoke"); + let result = instance.call("le", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1436 +fn c1424_l1436_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1424_l1436_action_invoke"); + let result = instance.call("le", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1437 +fn c1425_l1437_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1425_l1437_action_invoke"); + let result = instance.call("le", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1438 +fn c1426_l1438_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1426_l1438_action_invoke"); + let result = instance.call("le", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1439 +fn c1427_l1439_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1427_l1439_action_invoke"); + let result = instance.call("le", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1440 +fn c1428_l1440_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1428_l1440_action_invoke"); + let result = instance.call("le", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1441 +fn c1429_l1441_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1429_l1441_action_invoke"); + let result = instance.call("le", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1442 +fn c1430_l1442_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1430_l1442_action_invoke"); + let result = instance.call("le", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1443 +fn c1431_l1443_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1431_l1443_action_invoke"); + let result = instance.call("le", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1444 +fn c1432_l1444_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1432_l1444_action_invoke"); + let result = instance.call("le", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1445 +fn c1433_l1445_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1433_l1445_action_invoke"); + let result = instance.call("le", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1446 +fn c1434_l1446_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1434_l1446_action_invoke"); + let result = instance.call("le", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1447 +fn c1435_l1447_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1435_l1447_action_invoke"); + let result = instance.call("le", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1448 +fn c1436_l1448_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1436_l1448_action_invoke"); + let result = instance.call("le", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1449 +fn c1437_l1449_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1437_l1449_action_invoke"); + let result = instance.call("le", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1450 +fn c1438_l1450_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1438_l1450_action_invoke"); + let result = instance.call("le", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1451 +fn c1439_l1451_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1439_l1451_action_invoke"); + let result = instance.call("le", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1452 +fn c1440_l1452_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1440_l1452_action_invoke"); + let result = instance.call("le", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1453 +fn c1441_l1453_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1441_l1453_action_invoke"); + let result = instance.call("le", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1454 +fn c1442_l1454_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1442_l1454_action_invoke"); + let result = instance.call("le", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1455 +fn c1443_l1455_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1443_l1455_action_invoke"); + let result = instance.call("le", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1456 +fn c1444_l1456_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1444_l1456_action_invoke"); + let result = instance.call("le", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1457 +fn c1445_l1457_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1445_l1457_action_invoke"); + let result = instance.call("le", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1458 +fn c1446_l1458_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1446_l1458_action_invoke"); + let result = instance.call("le", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1459 +fn c1447_l1459_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1447_l1459_action_invoke"); + let result = instance.call("le", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1460 +fn c1448_l1460_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1448_l1460_action_invoke"); + let result = instance.call("le", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1461 +fn c1449_l1461_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1449_l1461_action_invoke"); + let result = instance.call("le", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1462 +fn c1450_l1462_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1450_l1462_action_invoke"); + let result = instance.call("le", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1463 +fn c1451_l1463_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1451_l1463_action_invoke"); + let result = instance.call("le", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1464 +fn c1452_l1464_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1452_l1464_action_invoke"); + let result = instance.call("le", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1465 +fn c1453_l1465_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1453_l1465_action_invoke"); + let result = instance.call("le", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1466 +fn c1454_l1466_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1454_l1466_action_invoke"); + let result = instance.call("le", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1467 +fn c1455_l1467_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1455_l1467_action_invoke"); + let result = instance.call("le", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1468 +fn c1456_l1468_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1456_l1468_action_invoke"); + let result = instance.call("le", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1469 +fn c1457_l1469_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1457_l1469_action_invoke"); + let result = instance.call("le", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1470 +fn c1458_l1470_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1458_l1470_action_invoke"); + let result = instance.call("le", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1471 +fn c1459_l1471_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1459_l1471_action_invoke"); + let result = instance.call("le", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1472 +fn c1460_l1472_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1460_l1472_action_invoke"); + let result = instance.call("le", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1473 +fn c1461_l1473_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1461_l1473_action_invoke"); + let result = instance.call("le", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1474 +fn c1462_l1474_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1462_l1474_action_invoke"); + let result = instance.call("le", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1475 +fn c1463_l1475_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1463_l1475_action_invoke"); + let result = instance.call("le", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1476 +fn c1464_l1476_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1464_l1476_action_invoke"); + let result = instance.call("le", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1477 +fn c1465_l1477_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1465_l1477_action_invoke"); + let result = instance.call("le", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1478 +fn c1466_l1478_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1466_l1478_action_invoke"); + let result = instance.call("le", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1479 +fn c1467_l1479_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1467_l1479_action_invoke"); + let result = instance.call("le", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1480 +fn c1468_l1480_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1468_l1480_action_invoke"); + let result = instance.call("le", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1481 +fn c1469_l1481_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1469_l1481_action_invoke"); + let result = instance.call("le", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1482 +fn c1470_l1482_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1470_l1482_action_invoke"); + let result = instance.call("le", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1483 +fn c1471_l1483_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1471_l1483_action_invoke"); + let result = instance.call("le", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1484 +fn c1472_l1484_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1472_l1484_action_invoke"); + let result = instance.call("le", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1485 +fn c1473_l1485_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1473_l1485_action_invoke"); + let result = instance.call("le", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1486 +fn c1474_l1486_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1474_l1486_action_invoke"); + let result = instance.call("le", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1487 +fn c1475_l1487_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1475_l1487_action_invoke"); + let result = instance.call("le", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1488 +fn c1476_l1488_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1476_l1488_action_invoke"); + let result = instance.call("le", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1489 +fn c1477_l1489_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1477_l1489_action_invoke"); + let result = instance.call("le", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1490 +fn c1478_l1490_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1478_l1490_action_invoke"); + let result = instance.call("le", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1491 +fn c1479_l1491_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1479_l1491_action_invoke"); + let result = instance.call("le", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1492 +fn c1480_l1492_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1480_l1492_action_invoke"); + let result = instance.call("le", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1493 +fn c1481_l1493_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1481_l1493_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1494 +fn c1482_l1494_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1482_l1494_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1495 +fn c1483_l1495_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1483_l1495_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1496 +fn c1484_l1496_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1484_l1496_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1497 +fn c1485_l1497_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1485_l1497_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1498 +fn c1486_l1498_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1486_l1498_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1499 +fn c1487_l1499_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1487_l1499_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1500 +fn c1488_l1500_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1488_l1500_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1501 +fn c1489_l1501_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1489_l1501_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1502 +fn c1490_l1502_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1490_l1502_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1503 +fn c1491_l1503_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1491_l1503_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1504 +fn c1492_l1504_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1492_l1504_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1505 +fn c1493_l1505_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1493_l1505_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1506 +fn c1494_l1506_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1494_l1506_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1507 +fn c1495_l1507_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1495_l1507_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1508 +fn c1496_l1508_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1496_l1508_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1509 +fn c1497_l1509_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1497_l1509_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1510 +fn c1498_l1510_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1498_l1510_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1511 +fn c1499_l1511_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1499_l1511_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1512 +fn c1500_l1512_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1500_l1512_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1513 +fn c1501_l1513_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1501_l1513_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1514 +fn c1502_l1514_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1502_l1514_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1515 +fn c1503_l1515_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1503_l1515_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1516 +fn c1504_l1516_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1504_l1516_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1517 +fn c1505_l1517_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1505_l1517_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1518 +fn c1506_l1518_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1506_l1518_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1519 +fn c1507_l1519_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1507_l1519_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1520 +fn c1508_l1520_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1508_l1520_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1521 +fn c1509_l1521_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1509_l1521_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1522 +fn c1510_l1522_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1510_l1522_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1523 +fn c1511_l1523_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1511_l1523_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1524 +fn c1512_l1524_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1512_l1524_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1525 +fn c1513_l1525_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1513_l1525_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1526 +fn c1514_l1526_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1514_l1526_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1527 +fn c1515_l1527_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1515_l1527_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1528 +fn c1516_l1528_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1516_l1528_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1529 +fn c1517_l1529_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1517_l1529_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1530 +fn c1518_l1530_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1518_l1530_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1531 +fn c1519_l1531_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1519_l1531_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1532 +fn c1520_l1532_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1520_l1532_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1533 +fn c1521_l1533_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1521_l1533_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1534 +fn c1522_l1534_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1522_l1534_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1535 +fn c1523_l1535_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1523_l1535_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1536 +fn c1524_l1536_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1524_l1536_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1537 +fn c1525_l1537_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1525_l1537_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1538 +fn c1526_l1538_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1526_l1538_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1539 +fn c1527_l1539_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1527_l1539_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1540 +fn c1528_l1540_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1528_l1540_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1541 +fn c1529_l1541_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1529_l1541_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1542 +fn c1530_l1542_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1530_l1542_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1543 +fn c1531_l1543_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1531_l1543_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1544 +fn c1532_l1544_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1532_l1544_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1545 +fn c1533_l1545_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1533_l1545_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1546 +fn c1534_l1546_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1534_l1546_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1547 +fn c1535_l1547_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1535_l1547_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1548 +fn c1536_l1548_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1536_l1548_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1549 +fn c1537_l1549_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1537_l1549_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1550 +fn c1538_l1550_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1538_l1550_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1551 +fn c1539_l1551_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1539_l1551_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1552 +fn c1540_l1552_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1540_l1552_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1553 +fn c1541_l1553_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1541_l1553_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1554 +fn c1542_l1554_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1542_l1554_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1555 +fn c1543_l1555_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1543_l1555_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1556 +fn c1544_l1556_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1544_l1556_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1557 +fn c1545_l1557_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1545_l1557_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1558 +fn c1546_l1558_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1546_l1558_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1559 +fn c1547_l1559_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1547_l1559_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1560 +fn c1548_l1560_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1548_l1560_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1561 +fn c1549_l1561_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1549_l1561_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1562 +fn c1550_l1562_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1550_l1562_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1563 +fn c1551_l1563_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1551_l1563_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1564 +fn c1552_l1564_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1552_l1564_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1565 +fn c1553_l1565_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1553_l1565_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1566 +fn c1554_l1566_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1554_l1566_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1567 +fn c1555_l1567_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1555_l1567_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1568 +fn c1556_l1568_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1556_l1568_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1569 +fn c1557_l1569_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1557_l1569_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1570 +fn c1558_l1570_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1558_l1570_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1571 +fn c1559_l1571_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1559_l1571_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1572 +fn c1560_l1572_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1560_l1572_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1573 +fn c1561_l1573_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1561_l1573_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1574 +fn c1562_l1574_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1562_l1574_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1575 +fn c1563_l1575_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1563_l1575_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1576 +fn c1564_l1576_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1564_l1576_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1577 +fn c1565_l1577_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1565_l1577_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1578 +fn c1566_l1578_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1566_l1578_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1579 +fn c1567_l1579_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1567_l1579_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1580 +fn c1568_l1580_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1568_l1580_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1581 +fn c1569_l1581_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1569_l1581_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1582 +fn c1570_l1582_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1570_l1582_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1583 +fn c1571_l1583_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1571_l1583_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1584 +fn c1572_l1584_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1572_l1584_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1585 +fn c1573_l1585_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1573_l1585_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1586 +fn c1574_l1586_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1574_l1586_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1587 +fn c1575_l1587_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1575_l1587_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1588 +fn c1576_l1588_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1576_l1588_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1589 +fn c1577_l1589_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1577_l1589_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1590 +fn c1578_l1590_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1578_l1590_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1591 +fn c1579_l1591_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1579_l1591_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1592 +fn c1580_l1592_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1580_l1592_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1593 +fn c1581_l1593_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1581_l1593_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1594 +fn c1582_l1594_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1582_l1594_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1595 +fn c1583_l1595_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1583_l1595_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1596 +fn c1584_l1596_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1584_l1596_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1597 +fn c1585_l1597_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1585_l1597_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1598 +fn c1586_l1598_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1586_l1598_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1599 +fn c1587_l1599_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1587_l1599_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1600 +fn c1588_l1600_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1588_l1600_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1601 +fn c1589_l1601_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1589_l1601_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1602 +fn c1590_l1602_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1590_l1602_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1603 +fn c1591_l1603_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1591_l1603_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1604 +fn c1592_l1604_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1592_l1604_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1605 +fn c1593_l1605_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1593_l1605_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1606 +fn c1594_l1606_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1594_l1606_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1607 +fn c1595_l1607_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1595_l1607_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1608 +fn c1596_l1608_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1596_l1608_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1609 +fn c1597_l1609_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1597_l1609_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1610 +fn c1598_l1610_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1598_l1610_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1611 +fn c1599_l1611_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1599_l1611_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1612 +fn c1600_l1612_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1600_l1612_action_invoke"); + let result = instance.call("le", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1613 +fn c1601_l1613_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1601_l1613_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1614 +fn c1602_l1614_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1602_l1614_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1615 +fn c1603_l1615_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1603_l1615_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1616 +fn c1604_l1616_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1604_l1616_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1617 +fn c1605_l1617_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1605_l1617_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1618 +fn c1606_l1618_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1606_l1618_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1619 +fn c1607_l1619_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1607_l1619_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1620 +fn c1608_l1620_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1608_l1620_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1621 +fn c1609_l1621_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1609_l1621_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1622 +fn c1610_l1622_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1610_l1622_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1623 +fn c1611_l1623_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1611_l1623_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1624 +fn c1612_l1624_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1612_l1624_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1625 +fn c1613_l1625_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1613_l1625_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1626 +fn c1614_l1626_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1614_l1626_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1627 +fn c1615_l1627_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1615_l1627_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1628 +fn c1616_l1628_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1616_l1628_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1629 +fn c1617_l1629_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1617_l1629_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1630 +fn c1618_l1630_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1618_l1630_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1631 +fn c1619_l1631_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1619_l1631_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1632 +fn c1620_l1632_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1620_l1632_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1633 +fn c1621_l1633_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1621_l1633_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1634 +fn c1622_l1634_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1622_l1634_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1635 +fn c1623_l1635_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1623_l1635_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1636 +fn c1624_l1636_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1624_l1636_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1637 +fn c1625_l1637_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1625_l1637_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1638 +fn c1626_l1638_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1626_l1638_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1639 +fn c1627_l1639_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1627_l1639_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1640 +fn c1628_l1640_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1628_l1640_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1641 +fn c1629_l1641_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1629_l1641_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1642 +fn c1630_l1642_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1630_l1642_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1643 +fn c1631_l1643_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1631_l1643_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1644 +fn c1632_l1644_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1632_l1644_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1645 +fn c1633_l1645_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1633_l1645_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1646 +fn c1634_l1646_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1634_l1646_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1647 +fn c1635_l1647_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1635_l1647_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1648 +fn c1636_l1648_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1636_l1648_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1649 +fn c1637_l1649_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1637_l1649_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1650 +fn c1638_l1650_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1638_l1650_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1651 +fn c1639_l1651_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1639_l1651_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1652 +fn c1640_l1652_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1640_l1652_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1653 +fn c1641_l1653_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1641_l1653_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1654 +fn c1642_l1654_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1642_l1654_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1655 +fn c1643_l1655_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1643_l1655_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1656 +fn c1644_l1656_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1644_l1656_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1657 +fn c1645_l1657_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1645_l1657_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1658 +fn c1646_l1658_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1646_l1658_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1659 +fn c1647_l1659_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1647_l1659_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1660 +fn c1648_l1660_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1648_l1660_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1661 +fn c1649_l1661_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1649_l1661_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1662 +fn c1650_l1662_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1650_l1662_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1663 +fn c1651_l1663_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1651_l1663_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1664 +fn c1652_l1664_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1652_l1664_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1665 +fn c1653_l1665_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1653_l1665_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1666 +fn c1654_l1666_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1654_l1666_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1667 +fn c1655_l1667_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1655_l1667_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1668 +fn c1656_l1668_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1656_l1668_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1669 +fn c1657_l1669_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1657_l1669_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1670 +fn c1658_l1670_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1658_l1670_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1671 +fn c1659_l1671_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1659_l1671_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1672 +fn c1660_l1672_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1660_l1672_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1673 +fn c1661_l1673_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1661_l1673_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1674 +fn c1662_l1674_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1662_l1674_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1675 +fn c1663_l1675_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1663_l1675_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1676 +fn c1664_l1676_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1664_l1676_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1677 +fn c1665_l1677_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1665_l1677_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1678 +fn c1666_l1678_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1666_l1678_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1679 +fn c1667_l1679_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1667_l1679_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1680 +fn c1668_l1680_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1668_l1680_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1681 +fn c1669_l1681_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1669_l1681_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1682 +fn c1670_l1682_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1670_l1682_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1683 +fn c1671_l1683_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1671_l1683_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1684 +fn c1672_l1684_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1672_l1684_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1685 +fn c1673_l1685_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1673_l1685_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1686 +fn c1674_l1686_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1674_l1686_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1687 +fn c1675_l1687_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1675_l1687_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1688 +fn c1676_l1688_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1676_l1688_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1689 +fn c1677_l1689_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1677_l1689_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1690 +fn c1678_l1690_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1678_l1690_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1691 +fn c1679_l1691_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1679_l1691_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1692 +fn c1680_l1692_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1680_l1692_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1693 +fn c1681_l1693_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1681_l1693_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1694 +fn c1682_l1694_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1682_l1694_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1695 +fn c1683_l1695_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1683_l1695_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1696 +fn c1684_l1696_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1684_l1696_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1697 +fn c1685_l1697_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1685_l1697_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1698 +fn c1686_l1698_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1686_l1698_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1699 +fn c1687_l1699_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1687_l1699_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1700 +fn c1688_l1700_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1688_l1700_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1701 +fn c1689_l1701_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1689_l1701_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1702 +fn c1690_l1702_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1690_l1702_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1703 +fn c1691_l1703_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1691_l1703_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1704 +fn c1692_l1704_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1692_l1704_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1705 +fn c1693_l1705_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1693_l1705_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1706 +fn c1694_l1706_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1694_l1706_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1707 +fn c1695_l1707_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1695_l1707_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1708 +fn c1696_l1708_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1696_l1708_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1709 +fn c1697_l1709_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1697_l1709_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1710 +fn c1698_l1710_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1698_l1710_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1711 +fn c1699_l1711_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1699_l1711_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1712 +fn c1700_l1712_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1700_l1712_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1713 +fn c1701_l1713_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1701_l1713_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1714 +fn c1702_l1714_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1702_l1714_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1715 +fn c1703_l1715_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1703_l1715_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1716 +fn c1704_l1716_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1704_l1716_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1717 +fn c1705_l1717_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1705_l1717_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1718 +fn c1706_l1718_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1706_l1718_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1719 +fn c1707_l1719_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1707_l1719_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1720 +fn c1708_l1720_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1708_l1720_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1721 +fn c1709_l1721_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1709_l1721_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1722 +fn c1710_l1722_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1710_l1722_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1723 +fn c1711_l1723_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1711_l1723_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1724 +fn c1712_l1724_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1712_l1724_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1725 +fn c1713_l1725_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1713_l1725_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1726 +fn c1714_l1726_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1714_l1726_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1727 +fn c1715_l1727_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1715_l1727_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1728 +fn c1716_l1728_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1716_l1728_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1729 +fn c1717_l1729_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1717_l1729_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1730 +fn c1718_l1730_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1718_l1730_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1731 +fn c1719_l1731_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1719_l1731_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1732 +fn c1720_l1732_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1720_l1732_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1733 +fn c1721_l1733_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1721_l1733_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1734 +fn c1722_l1734_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1722_l1734_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1735 +fn c1723_l1735_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1723_l1735_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1736 +fn c1724_l1736_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1724_l1736_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.5f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1737 +fn c1725_l1737_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1725_l1737_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1738 +fn c1726_l1738_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1726_l1738_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1739 +fn c1727_l1739_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1727_l1739_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1740 +fn c1728_l1740_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1728_l1740_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1741 +fn c1729_l1741_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1729_l1741_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1742 +fn c1730_l1742_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1730_l1742_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1743 +fn c1731_l1743_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1731_l1743_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1744 +fn c1732_l1744_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1732_l1744_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1745 +fn c1733_l1745_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1733_l1745_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1746 +fn c1734_l1746_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1734_l1746_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1747 +fn c1735_l1747_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1735_l1747_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1748 +fn c1736_l1748_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1736_l1748_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.5f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1749 +fn c1737_l1749_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1737_l1749_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.5f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1750 +fn c1738_l1750_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1738_l1750_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.5f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1751 +fn c1739_l1751_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1739_l1751_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.5f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1752 +fn c1740_l1752_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1740_l1752_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.5f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1753 +fn c1741_l1753_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1741_l1753_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.5f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1754 +fn c1742_l1754_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1742_l1754_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.5f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1755 +fn c1743_l1755_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1743_l1755_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.5f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1756 +fn c1744_l1756_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1744_l1756_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.5f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1757 +fn c1745_l1757_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1745_l1757_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.5f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1758 +fn c1746_l1758_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1746_l1758_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.5f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1759 +fn c1747_l1759_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1747_l1759_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.5f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1760 +fn c1748_l1760_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1748_l1760_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.5f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1761 +fn c1749_l1761_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1749_l1761_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1762 +fn c1750_l1762_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1750_l1762_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1763 +fn c1751_l1763_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1751_l1763_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1764 +fn c1752_l1764_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1752_l1764_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1765 +fn c1753_l1765_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1753_l1765_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1766 +fn c1754_l1766_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1754_l1766_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1767 +fn c1755_l1767_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1755_l1767_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1768 +fn c1756_l1768_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1756_l1768_action_invoke"); + let result = instance.call("gt", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1769 +fn c1757_l1769_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1757_l1769_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1770 +fn c1758_l1770_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1758_l1770_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1771 +fn c1759_l1771_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1759_l1771_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1772 +fn c1760_l1772_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1760_l1772_action_invoke"); + let result = instance.call("gt", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1773 +fn c1761_l1773_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1761_l1773_action_invoke"); + let result = instance.call("gt", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1774 +fn c1762_l1774_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1762_l1774_action_invoke"); + let result = instance.call("gt", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1775 +fn c1763_l1775_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1763_l1775_action_invoke"); + let result = instance.call("gt", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1776 +fn c1764_l1776_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1764_l1776_action_invoke"); + let result = instance.call("gt", &[Value::F64((1.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1777 +fn c1765_l1777_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1765_l1777_action_invoke"); + let result = instance.call("gt", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1778 +fn c1766_l1778_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1766_l1778_action_invoke"); + let result = instance.call("gt", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1779 +fn c1767_l1779_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1767_l1779_action_invoke"); + let result = instance.call("gt", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1780 +fn c1768_l1780_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1768_l1780_action_invoke"); + let result = instance.call("gt", &[Value::F64((1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1781 +fn c1769_l1781_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1769_l1781_action_invoke"); + let result = instance.call("gt", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1782 +fn c1770_l1782_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1770_l1782_action_invoke"); + let result = instance.call("gt", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1783 +fn c1771_l1783_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1771_l1783_action_invoke"); + let result = instance.call("gt", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1784 +fn c1772_l1784_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1772_l1784_action_invoke"); + let result = instance.call("gt", &[Value::F64((1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1785 +fn c1773_l1785_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1773_l1785_action_invoke"); + let result = instance.call("gt", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1786 +fn c1774_l1786_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1774_l1786_action_invoke"); + let result = instance.call("gt", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1787 +fn c1775_l1787_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1775_l1787_action_invoke"); + let result = instance.call("gt", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1788 +fn c1776_l1788_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1776_l1788_action_invoke"); + let result = instance.call("gt", &[Value::F64((1.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1789 +fn c1777_l1789_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1777_l1789_action_invoke"); + let result = instance.call("gt", &[Value::F64((-1.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1790 +fn c1778_l1790_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1778_l1790_action_invoke"); + let result = instance.call("gt", &[Value::F64((-1.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1791 +fn c1779_l1791_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1779_l1791_action_invoke"); + let result = instance.call("gt", &[Value::F64((1.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1792 +fn c1780_l1792_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1780_l1792_action_invoke"); + let result = instance.call("gt", &[Value::F64((1.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1793 +fn c1781_l1793_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1781_l1793_action_invoke"); + let result = instance.call("gt", &[Value::F64((-1.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1794 +fn c1782_l1794_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1782_l1794_action_invoke"); + let result = instance.call("gt", &[Value::F64((-1.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1795 +fn c1783_l1795_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1783_l1795_action_invoke"); + let result = instance.call("gt", &[Value::F64((1.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1796 +fn c1784_l1796_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1784_l1796_action_invoke"); + let result = instance.call("gt", &[Value::F64((1.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1797 +fn c1785_l1797_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1785_l1797_action_invoke"); + let result = instance.call("gt", &[Value::F64((-1.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1798 +fn c1786_l1798_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1786_l1798_action_invoke"); + let result = instance.call("gt", &[Value::F64((-1.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1799 +fn c1787_l1799_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1787_l1799_action_invoke"); + let result = instance.call("gt", &[Value::F64((1.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1800 +fn c1788_l1800_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1788_l1800_action_invoke"); + let result = instance.call("gt", &[Value::F64((1.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1801 +fn c1789_l1801_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1789_l1801_action_invoke"); + let result = instance.call("gt", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1802 +fn c1790_l1802_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1790_l1802_action_invoke"); + let result = instance.call("gt", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1803 +fn c1791_l1803_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1791_l1803_action_invoke"); + let result = instance.call("gt", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1804 +fn c1792_l1804_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1792_l1804_action_invoke"); + let result = instance.call("gt", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1805 +fn c1793_l1805_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1793_l1805_action_invoke"); + let result = instance.call("gt", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1806 +fn c1794_l1806_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1794_l1806_action_invoke"); + let result = instance.call("gt", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1807 +fn c1795_l1807_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1795_l1807_action_invoke"); + let result = instance.call("gt", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1808 +fn c1796_l1808_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1796_l1808_action_invoke"); + let result = instance.call("gt", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1809 +fn c1797_l1809_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1797_l1809_action_invoke"); + let result = instance.call("gt", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1810 +fn c1798_l1810_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1798_l1810_action_invoke"); + let result = instance.call("gt", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1811 +fn c1799_l1811_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1799_l1811_action_invoke"); + let result = instance.call("gt", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1812 +fn c1800_l1812_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1800_l1812_action_invoke"); + let result = instance.call("gt", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1813 +fn c1801_l1813_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1801_l1813_action_invoke"); + let result = instance.call("gt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1814 +fn c1802_l1814_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1802_l1814_action_invoke"); + let result = instance.call("gt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1815 +fn c1803_l1815_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1803_l1815_action_invoke"); + let result = instance.call("gt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1816 +fn c1804_l1816_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1804_l1816_action_invoke"); + let result = instance.call("gt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1817 +fn c1805_l1817_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1805_l1817_action_invoke"); + let result = instance.call("gt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1818 +fn c1806_l1818_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1806_l1818_action_invoke"); + let result = instance.call("gt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1819 +fn c1807_l1819_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1807_l1819_action_invoke"); + let result = instance.call("gt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1820 +fn c1808_l1820_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1808_l1820_action_invoke"); + let result = instance.call("gt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1821 +fn c1809_l1821_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1809_l1821_action_invoke"); + let result = instance.call("gt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1822 +fn c1810_l1822_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1810_l1822_action_invoke"); + let result = instance.call("gt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1823 +fn c1811_l1823_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1811_l1823_action_invoke"); + let result = instance.call("gt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1824 +fn c1812_l1824_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1812_l1824_action_invoke"); + let result = instance.call("gt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1825 +fn c1813_l1825_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1813_l1825_action_invoke"); + let result = instance.call("gt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1826 +fn c1814_l1826_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1814_l1826_action_invoke"); + let result = instance.call("gt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1827 +fn c1815_l1827_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1815_l1827_action_invoke"); + let result = instance.call("gt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1828 +fn c1816_l1828_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1816_l1828_action_invoke"); + let result = instance.call("gt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1829 +fn c1817_l1829_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1817_l1829_action_invoke"); + let result = instance.call("gt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1830 +fn c1818_l1830_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1818_l1830_action_invoke"); + let result = instance.call("gt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1831 +fn c1819_l1831_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1819_l1831_action_invoke"); + let result = instance.call("gt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1832 +fn c1820_l1832_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1820_l1832_action_invoke"); + let result = instance.call("gt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1833 +fn c1821_l1833_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1821_l1833_action_invoke"); + let result = instance.call("gt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1834 +fn c1822_l1834_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1822_l1834_action_invoke"); + let result = instance.call("gt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1835 +fn c1823_l1835_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1823_l1835_action_invoke"); + let result = instance.call("gt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1836 +fn c1824_l1836_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1824_l1836_action_invoke"); + let result = instance.call("gt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1837 +fn c1825_l1837_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1825_l1837_action_invoke"); + let result = instance.call("gt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1838 +fn c1826_l1838_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1826_l1838_action_invoke"); + let result = instance.call("gt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1839 +fn c1827_l1839_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1827_l1839_action_invoke"); + let result = instance.call("gt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1840 +fn c1828_l1840_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1828_l1840_action_invoke"); + let result = instance.call("gt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1841 +fn c1829_l1841_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1829_l1841_action_invoke"); + let result = instance.call("gt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1842 +fn c1830_l1842_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1830_l1842_action_invoke"); + let result = instance.call("gt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1843 +fn c1831_l1843_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1831_l1843_action_invoke"); + let result = instance.call("gt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1844 +fn c1832_l1844_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1832_l1844_action_invoke"); + let result = instance.call("gt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1845 +fn c1833_l1845_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1833_l1845_action_invoke"); + let result = instance.call("gt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1846 +fn c1834_l1846_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1834_l1846_action_invoke"); + let result = instance.call("gt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1847 +fn c1835_l1847_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1835_l1847_action_invoke"); + let result = instance.call("gt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1848 +fn c1836_l1848_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1836_l1848_action_invoke"); + let result = instance.call("gt", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1849 +fn c1837_l1849_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1837_l1849_action_invoke"); + let result = instance.call("gt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1850 +fn c1838_l1850_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1838_l1850_action_invoke"); + let result = instance.call("gt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1851 +fn c1839_l1851_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1839_l1851_action_invoke"); + let result = instance.call("gt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1852 +fn c1840_l1852_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1840_l1852_action_invoke"); + let result = instance.call("gt", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1853 +fn c1841_l1853_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1841_l1853_action_invoke"); + let result = instance.call("gt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1854 +fn c1842_l1854_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1842_l1854_action_invoke"); + let result = instance.call("gt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1855 +fn c1843_l1855_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1843_l1855_action_invoke"); + let result = instance.call("gt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1856 +fn c1844_l1856_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1844_l1856_action_invoke"); + let result = instance.call("gt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1857 +fn c1845_l1857_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1845_l1857_action_invoke"); + let result = instance.call("gt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1858 +fn c1846_l1858_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1846_l1858_action_invoke"); + let result = instance.call("gt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1859 +fn c1847_l1859_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1847_l1859_action_invoke"); + let result = instance.call("gt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1860 +fn c1848_l1860_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1848_l1860_action_invoke"); + let result = instance.call("gt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1861 +fn c1849_l1861_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1849_l1861_action_invoke"); + let result = instance.call("gt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1862 +fn c1850_l1862_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1850_l1862_action_invoke"); + let result = instance.call("gt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1863 +fn c1851_l1863_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1851_l1863_action_invoke"); + let result = instance.call("gt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1864 +fn c1852_l1864_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1852_l1864_action_invoke"); + let result = instance.call("gt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1865 +fn c1853_l1865_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1853_l1865_action_invoke"); + let result = instance.call("gt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1866 +fn c1854_l1866_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1854_l1866_action_invoke"); + let result = instance.call("gt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1867 +fn c1855_l1867_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1855_l1867_action_invoke"); + let result = instance.call("gt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1868 +fn c1856_l1868_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1856_l1868_action_invoke"); + let result = instance.call("gt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1869 +fn c1857_l1869_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1857_l1869_action_invoke"); + let result = instance.call("gt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1870 +fn c1858_l1870_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1858_l1870_action_invoke"); + let result = instance.call("gt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1871 +fn c1859_l1871_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1859_l1871_action_invoke"); + let result = instance.call("gt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1872 +fn c1860_l1872_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1860_l1872_action_invoke"); + let result = instance.call("gt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1873 +fn c1861_l1873_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1861_l1873_action_invoke"); + let result = instance.call("gt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1874 +fn c1862_l1874_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1862_l1874_action_invoke"); + let result = instance.call("gt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1875 +fn c1863_l1875_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1863_l1875_action_invoke"); + let result = instance.call("gt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1876 +fn c1864_l1876_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1864_l1876_action_invoke"); + let result = instance.call("gt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1877 +fn c1865_l1877_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1865_l1877_action_invoke"); + let result = instance.call("gt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1878 +fn c1866_l1878_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1866_l1878_action_invoke"); + let result = instance.call("gt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1879 +fn c1867_l1879_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1867_l1879_action_invoke"); + let result = instance.call("gt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1880 +fn c1868_l1880_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1868_l1880_action_invoke"); + let result = instance.call("gt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1881 +fn c1869_l1881_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1869_l1881_action_invoke"); + let result = instance.call("gt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1882 +fn c1870_l1882_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1870_l1882_action_invoke"); + let result = instance.call("gt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1883 +fn c1871_l1883_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1871_l1883_action_invoke"); + let result = instance.call("gt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1884 +fn c1872_l1884_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1872_l1884_action_invoke"); + let result = instance.call("gt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1885 +fn c1873_l1885_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1873_l1885_action_invoke"); + let result = instance.call("gt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1886 +fn c1874_l1886_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1874_l1886_action_invoke"); + let result = instance.call("gt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1887 +fn c1875_l1887_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1875_l1887_action_invoke"); + let result = instance.call("gt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1888 +fn c1876_l1888_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1876_l1888_action_invoke"); + let result = instance.call("gt", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1889 +fn c1877_l1889_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1877_l1889_action_invoke"); + let result = instance.call("gt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1890 +fn c1878_l1890_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1878_l1890_action_invoke"); + let result = instance.call("gt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1891 +fn c1879_l1891_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1879_l1891_action_invoke"); + let result = instance.call("gt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1892 +fn c1880_l1892_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1880_l1892_action_invoke"); + let result = instance.call("gt", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1893 +fn c1881_l1893_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1881_l1893_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1894 +fn c1882_l1894_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1882_l1894_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1895 +fn c1883_l1895_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1883_l1895_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1896 +fn c1884_l1896_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1884_l1896_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1897 +fn c1885_l1897_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1885_l1897_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1898 +fn c1886_l1898_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1886_l1898_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1899 +fn c1887_l1899_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1887_l1899_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1900 +fn c1888_l1900_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1888_l1900_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1901 +fn c1889_l1901_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1889_l1901_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1902 +fn c1890_l1902_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1890_l1902_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1903 +fn c1891_l1903_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1891_l1903_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1904 +fn c1892_l1904_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1892_l1904_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1905 +fn c1893_l1905_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1893_l1905_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1906 +fn c1894_l1906_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1894_l1906_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1907 +fn c1895_l1907_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1895_l1907_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1908 +fn c1896_l1908_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1896_l1908_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1909 +fn c1897_l1909_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1897_l1909_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1910 +fn c1898_l1910_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1898_l1910_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1911 +fn c1899_l1911_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1899_l1911_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1912 +fn c1900_l1912_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1900_l1912_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1913 +fn c1901_l1913_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1901_l1913_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1914 +fn c1902_l1914_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1902_l1914_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1915 +fn c1903_l1915_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1903_l1915_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1916 +fn c1904_l1916_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1904_l1916_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1917 +fn c1905_l1917_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1905_l1917_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1918 +fn c1906_l1918_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1906_l1918_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1919 +fn c1907_l1919_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1907_l1919_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1920 +fn c1908_l1920_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1908_l1920_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1921 +fn c1909_l1921_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1909_l1921_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1922 +fn c1910_l1922_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1910_l1922_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1923 +fn c1911_l1923_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1911_l1923_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1924 +fn c1912_l1924_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1912_l1924_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1925 +fn c1913_l1925_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1913_l1925_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1926 +fn c1914_l1926_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1914_l1926_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1927 +fn c1915_l1927_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1915_l1927_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1928 +fn c1916_l1928_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1916_l1928_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1929 +fn c1917_l1929_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1917_l1929_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1930 +fn c1918_l1930_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1918_l1930_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1931 +fn c1919_l1931_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1919_l1931_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1932 +fn c1920_l1932_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1920_l1932_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1933 +fn c1921_l1933_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1921_l1933_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1934 +fn c1922_l1934_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1922_l1934_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1935 +fn c1923_l1935_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1923_l1935_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1936 +fn c1924_l1936_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1924_l1936_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1937 +fn c1925_l1937_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1925_l1937_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1938 +fn c1926_l1938_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1926_l1938_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1939 +fn c1927_l1939_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1927_l1939_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1940 +fn c1928_l1940_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1928_l1940_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1941 +fn c1929_l1941_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1929_l1941_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1942 +fn c1930_l1942_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1930_l1942_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1943 +fn c1931_l1943_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1931_l1943_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1944 +fn c1932_l1944_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1932_l1944_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1945 +fn c1933_l1945_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1933_l1945_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1946 +fn c1934_l1946_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1934_l1946_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1947 +fn c1935_l1947_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1935_l1947_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1948 +fn c1936_l1948_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1936_l1948_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1949 +fn c1937_l1949_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1937_l1949_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1950 +fn c1938_l1950_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1938_l1950_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1951 +fn c1939_l1951_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1939_l1951_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1952 +fn c1940_l1952_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1940_l1952_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1953 +fn c1941_l1953_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1941_l1953_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1954 +fn c1942_l1954_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1942_l1954_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1955 +fn c1943_l1955_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1943_l1955_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1956 +fn c1944_l1956_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1944_l1956_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1957 +fn c1945_l1957_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1945_l1957_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1958 +fn c1946_l1958_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1946_l1958_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1959 +fn c1947_l1959_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1947_l1959_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1960 +fn c1948_l1960_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1948_l1960_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1961 +fn c1949_l1961_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1949_l1961_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1962 +fn c1950_l1962_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1950_l1962_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1963 +fn c1951_l1963_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1951_l1963_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1964 +fn c1952_l1964_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1952_l1964_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1965 +fn c1953_l1965_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1953_l1965_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1966 +fn c1954_l1966_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1954_l1966_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1967 +fn c1955_l1967_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1955_l1967_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1968 +fn c1956_l1968_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1956_l1968_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1969 +fn c1957_l1969_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1957_l1969_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1970 +fn c1958_l1970_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1958_l1970_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1971 +fn c1959_l1971_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1959_l1971_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1972 +fn c1960_l1972_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1960_l1972_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1973 +fn c1961_l1973_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1961_l1973_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1974 +fn c1962_l1974_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1962_l1974_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1975 +fn c1963_l1975_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1963_l1975_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1976 +fn c1964_l1976_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1964_l1976_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1977 +fn c1965_l1977_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1965_l1977_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1978 +fn c1966_l1978_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1966_l1978_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1979 +fn c1967_l1979_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1967_l1979_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1980 +fn c1968_l1980_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1968_l1980_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1981 +fn c1969_l1981_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1969_l1981_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1982 +fn c1970_l1982_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1970_l1982_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1983 +fn c1971_l1983_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1971_l1983_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1984 +fn c1972_l1984_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1972_l1984_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1985 +fn c1973_l1985_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1973_l1985_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1986 +fn c1974_l1986_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1974_l1986_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1987 +fn c1975_l1987_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1975_l1987_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1988 +fn c1976_l1988_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1976_l1988_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1989 +fn c1977_l1989_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1977_l1989_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1990 +fn c1978_l1990_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1978_l1990_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1991 +fn c1979_l1991_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1979_l1991_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1992 +fn c1980_l1992_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1980_l1992_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1993 +fn c1981_l1993_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1981_l1993_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1994 +fn c1982_l1994_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1982_l1994_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1995 +fn c1983_l1995_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1983_l1995_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1996 +fn c1984_l1996_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1984_l1996_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1997 +fn c1985_l1997_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1985_l1997_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1998 +fn c1986_l1998_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1986_l1998_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1999 +fn c1987_l1999_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1987_l1999_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2000 +fn c1988_l2000_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1988_l2000_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2001 +fn c1989_l2001_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1989_l2001_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2002 +fn c1990_l2002_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1990_l2002_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2003 +fn c1991_l2003_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1991_l2003_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2004 +fn c1992_l2004_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1992_l2004_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2005 +fn c1993_l2005_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1993_l2005_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2006 +fn c1994_l2006_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1994_l2006_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2007 +fn c1995_l2007_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1995_l2007_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2008 +fn c1996_l2008_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1996_l2008_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2009 +fn c1997_l2009_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1997_l2009_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2010 +fn c1998_l2010_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1998_l2010_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2011 +fn c1999_l2011_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1999_l2011_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2012 +fn c2000_l2012_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2000_l2012_action_invoke"); + let result = instance.call("gt", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2013 +fn c2001_l2013_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2001_l2013_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2014 +fn c2002_l2014_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2002_l2014_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2015 +fn c2003_l2015_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2003_l2015_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2016 +fn c2004_l2016_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2004_l2016_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2017 +fn c2005_l2017_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2005_l2017_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2018 +fn c2006_l2018_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2006_l2018_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2019 +fn c2007_l2019_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2007_l2019_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2020 +fn c2008_l2020_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2008_l2020_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2021 +fn c2009_l2021_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2009_l2021_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2022 +fn c2010_l2022_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2010_l2022_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2023 +fn c2011_l2023_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2011_l2023_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2024 +fn c2012_l2024_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2012_l2024_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2025 +fn c2013_l2025_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2013_l2025_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2026 +fn c2014_l2026_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2014_l2026_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2027 +fn c2015_l2027_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2015_l2027_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2028 +fn c2016_l2028_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2016_l2028_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2029 +fn c2017_l2029_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2017_l2029_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2030 +fn c2018_l2030_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2018_l2030_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2031 +fn c2019_l2031_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2019_l2031_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2032 +fn c2020_l2032_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2020_l2032_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2033 +fn c2021_l2033_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2021_l2033_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2034 +fn c2022_l2034_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2022_l2034_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2035 +fn c2023_l2035_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2023_l2035_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2036 +fn c2024_l2036_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2024_l2036_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2037 +fn c2025_l2037_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2025_l2037_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2038 +fn c2026_l2038_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2026_l2038_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2039 +fn c2027_l2039_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2027_l2039_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2040 +fn c2028_l2040_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2028_l2040_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2041 +fn c2029_l2041_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2029_l2041_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2042 +fn c2030_l2042_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2030_l2042_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2043 +fn c2031_l2043_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2031_l2043_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2044 +fn c2032_l2044_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2032_l2044_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2045 +fn c2033_l2045_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2033_l2045_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2046 +fn c2034_l2046_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2034_l2046_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2047 +fn c2035_l2047_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2035_l2047_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2048 +fn c2036_l2048_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2036_l2048_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2049 +fn c2037_l2049_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2037_l2049_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2050 +fn c2038_l2050_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2038_l2050_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2051 +fn c2039_l2051_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2039_l2051_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2052 +fn c2040_l2052_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2040_l2052_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2053 +fn c2041_l2053_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2041_l2053_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2054 +fn c2042_l2054_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2042_l2054_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2055 +fn c2043_l2055_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2043_l2055_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2056 +fn c2044_l2056_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2044_l2056_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2057 +fn c2045_l2057_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2045_l2057_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2058 +fn c2046_l2058_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2046_l2058_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2059 +fn c2047_l2059_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2047_l2059_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2060 +fn c2048_l2060_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2048_l2060_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2061 +fn c2049_l2061_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2049_l2061_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2062 +fn c2050_l2062_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2050_l2062_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2063 +fn c2051_l2063_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2051_l2063_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2064 +fn c2052_l2064_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2052_l2064_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2065 +fn c2053_l2065_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2053_l2065_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2066 +fn c2054_l2066_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2054_l2066_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2067 +fn c2055_l2067_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2055_l2067_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2068 +fn c2056_l2068_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2056_l2068_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2069 +fn c2057_l2069_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2057_l2069_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2070 +fn c2058_l2070_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2058_l2070_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2071 +fn c2059_l2071_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2059_l2071_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2072 +fn c2060_l2072_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2060_l2072_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2073 +fn c2061_l2073_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2061_l2073_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2074 +fn c2062_l2074_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2062_l2074_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2075 +fn c2063_l2075_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2063_l2075_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2076 +fn c2064_l2076_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2064_l2076_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2077 +fn c2065_l2077_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2065_l2077_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2078 +fn c2066_l2078_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2066_l2078_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2079 +fn c2067_l2079_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2067_l2079_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2080 +fn c2068_l2080_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2068_l2080_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2081 +fn c2069_l2081_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2069_l2081_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2082 +fn c2070_l2082_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2070_l2082_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2083 +fn c2071_l2083_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2071_l2083_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2084 +fn c2072_l2084_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2072_l2084_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2085 +fn c2073_l2085_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2073_l2085_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2086 +fn c2074_l2086_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2074_l2086_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2087 +fn c2075_l2087_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2075_l2087_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2088 +fn c2076_l2088_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2076_l2088_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2089 +fn c2077_l2089_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2077_l2089_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2090 +fn c2078_l2090_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2078_l2090_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2091 +fn c2079_l2091_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2079_l2091_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2092 +fn c2080_l2092_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2080_l2092_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2093 +fn c2081_l2093_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2081_l2093_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2094 +fn c2082_l2094_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2082_l2094_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2095 +fn c2083_l2095_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2083_l2095_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2096 +fn c2084_l2096_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2084_l2096_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2097 +fn c2085_l2097_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2085_l2097_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2098 +fn c2086_l2098_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2086_l2098_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2099 +fn c2087_l2099_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2087_l2099_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2100 +fn c2088_l2100_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2088_l2100_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2101 +fn c2089_l2101_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2089_l2101_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2102 +fn c2090_l2102_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2090_l2102_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2103 +fn c2091_l2103_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2091_l2103_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2104 +fn c2092_l2104_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2092_l2104_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2105 +fn c2093_l2105_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2093_l2105_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2106 +fn c2094_l2106_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2094_l2106_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2107 +fn c2095_l2107_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2095_l2107_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2108 +fn c2096_l2108_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2096_l2108_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2109 +fn c2097_l2109_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2097_l2109_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2110 +fn c2098_l2110_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2098_l2110_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2111 +fn c2099_l2111_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2099_l2111_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2112 +fn c2100_l2112_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2100_l2112_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2113 +fn c2101_l2113_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2101_l2113_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2114 +fn c2102_l2114_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2102_l2114_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2115 +fn c2103_l2115_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2103_l2115_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2116 +fn c2104_l2116_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2104_l2116_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2117 +fn c2105_l2117_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2105_l2117_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2118 +fn c2106_l2118_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2106_l2118_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2119 +fn c2107_l2119_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2107_l2119_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2120 +fn c2108_l2120_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2108_l2120_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2121 +fn c2109_l2121_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2109_l2121_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2122 +fn c2110_l2122_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2110_l2122_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2123 +fn c2111_l2123_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2111_l2123_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2124 +fn c2112_l2124_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2112_l2124_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2125 +fn c2113_l2125_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2113_l2125_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2126 +fn c2114_l2126_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2114_l2126_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2127 +fn c2115_l2127_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2115_l2127_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2128 +fn c2116_l2128_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2116_l2128_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2129 +fn c2117_l2129_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2117_l2129_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2130 +fn c2118_l2130_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2118_l2130_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2131 +fn c2119_l2131_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2119_l2131_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2132 +fn c2120_l2132_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2120_l2132_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2133 +fn c2121_l2133_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2121_l2133_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2134 +fn c2122_l2134_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2122_l2134_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2135 +fn c2123_l2135_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2123_l2135_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2136 +fn c2124_l2136_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2124_l2136_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.5f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2137 +fn c2125_l2137_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2125_l2137_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2138 +fn c2126_l2138_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2126_l2138_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2139 +fn c2127_l2139_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2127_l2139_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2140 +fn c2128_l2140_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2128_l2140_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2141 +fn c2129_l2141_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2129_l2141_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2142 +fn c2130_l2142_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2130_l2142_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2143 +fn c2131_l2143_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2131_l2143_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2144 +fn c2132_l2144_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2132_l2144_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.5f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2145 +fn c2133_l2145_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2133_l2145_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.5f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2146 +fn c2134_l2146_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2134_l2146_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.5f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2147 +fn c2135_l2147_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2135_l2147_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.5f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2148 +fn c2136_l2148_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2136_l2148_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.5f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2149 +fn c2137_l2149_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2137_l2149_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.5f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2150 +fn c2138_l2150_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2138_l2150_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.5f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2151 +fn c2139_l2151_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2139_l2151_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.5f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2152 +fn c2140_l2152_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2140_l2152_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.5f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2153 +fn c2141_l2153_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2141_l2153_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.5f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2154 +fn c2142_l2154_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2142_l2154_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.5f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2155 +fn c2143_l2155_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2143_l2155_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.5f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2156 +fn c2144_l2156_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2144_l2156_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.5f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2157 +fn c2145_l2157_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2145_l2157_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.5f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2158 +fn c2146_l2158_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2146_l2158_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.5f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2159 +fn c2147_l2159_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2147_l2159_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.5f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2160 +fn c2148_l2160_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2148_l2160_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.5f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2161 +fn c2149_l2161_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2149_l2161_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2162 +fn c2150_l2162_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2150_l2162_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2163 +fn c2151_l2163_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2151_l2163_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2164 +fn c2152_l2164_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2152_l2164_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2165 +fn c2153_l2165_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2153_l2165_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2166 +fn c2154_l2166_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2154_l2166_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2167 +fn c2155_l2167_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2155_l2167_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2168 +fn c2156_l2168_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2156_l2168_action_invoke"); + let result = instance.call("ge", &[Value::F64((-0.5f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2169 +fn c2157_l2169_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2157_l2169_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2170 +fn c2158_l2170_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2158_l2170_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2171 +fn c2159_l2171_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2159_l2171_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2172 +fn c2160_l2172_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2160_l2172_action_invoke"); + let result = instance.call("ge", &[Value::F64((0.5f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2173 +fn c2161_l2173_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2161_l2173_action_invoke"); + let result = instance.call("ge", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2174 +fn c2162_l2174_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2162_l2174_action_invoke"); + let result = instance.call("ge", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2175 +fn c2163_l2175_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2163_l2175_action_invoke"); + let result = instance.call("ge", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2176 +fn c2164_l2176_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2164_l2176_action_invoke"); + let result = instance.call("ge", &[Value::F64((1.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2177 +fn c2165_l2177_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2165_l2177_action_invoke"); + let result = instance.call("ge", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2178 +fn c2166_l2178_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2166_l2178_action_invoke"); + let result = instance.call("ge", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2179 +fn c2167_l2179_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2167_l2179_action_invoke"); + let result = instance.call("ge", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2180 +fn c2168_l2180_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2168_l2180_action_invoke"); + let result = instance.call("ge", &[Value::F64((1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2181 +fn c2169_l2181_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2169_l2181_action_invoke"); + let result = instance.call("ge", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2182 +fn c2170_l2182_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2170_l2182_action_invoke"); + let result = instance.call("ge", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2183 +fn c2171_l2183_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2171_l2183_action_invoke"); + let result = instance.call("ge", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2184 +fn c2172_l2184_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2172_l2184_action_invoke"); + let result = instance.call("ge", &[Value::F64((1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2185 +fn c2173_l2185_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2173_l2185_action_invoke"); + let result = instance.call("ge", &[Value::F64((-1.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2186 +fn c2174_l2186_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2174_l2186_action_invoke"); + let result = instance.call("ge", &[Value::F64((-1.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2187 +fn c2175_l2187_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2175_l2187_action_invoke"); + let result = instance.call("ge", &[Value::F64((1.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2188 +fn c2176_l2188_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2176_l2188_action_invoke"); + let result = instance.call("ge", &[Value::F64((1.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2189 +fn c2177_l2189_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2177_l2189_action_invoke"); + let result = instance.call("ge", &[Value::F64((-1.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2190 +fn c2178_l2190_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2178_l2190_action_invoke"); + let result = instance.call("ge", &[Value::F64((-1.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2191 +fn c2179_l2191_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2179_l2191_action_invoke"); + let result = instance.call("ge", &[Value::F64((1.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2192 +fn c2180_l2192_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2180_l2192_action_invoke"); + let result = instance.call("ge", &[Value::F64((1.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2193 +fn c2181_l2193_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2181_l2193_action_invoke"); + let result = instance.call("ge", &[Value::F64((-1.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2194 +fn c2182_l2194_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2182_l2194_action_invoke"); + let result = instance.call("ge", &[Value::F64((-1.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2195 +fn c2183_l2195_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2183_l2195_action_invoke"); + let result = instance.call("ge", &[Value::F64((1.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2196 +fn c2184_l2196_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2184_l2196_action_invoke"); + let result = instance.call("ge", &[Value::F64((1.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2197 +fn c2185_l2197_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2185_l2197_action_invoke"); + let result = instance.call("ge", &[Value::F64((-1.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2198 +fn c2186_l2198_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2186_l2198_action_invoke"); + let result = instance.call("ge", &[Value::F64((-1.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2199 +fn c2187_l2199_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2187_l2199_action_invoke"); + let result = instance.call("ge", &[Value::F64((1.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2200 +fn c2188_l2200_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2188_l2200_action_invoke"); + let result = instance.call("ge", &[Value::F64((1.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2201 +fn c2189_l2201_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2189_l2201_action_invoke"); + let result = instance.call("ge", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2202 +fn c2190_l2202_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2190_l2202_action_invoke"); + let result = instance.call("ge", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2203 +fn c2191_l2203_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2191_l2203_action_invoke"); + let result = instance.call("ge", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2204 +fn c2192_l2204_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2192_l2204_action_invoke"); + let result = instance.call("ge", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2205 +fn c2193_l2205_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2193_l2205_action_invoke"); + let result = instance.call("ge", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2206 +fn c2194_l2206_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2194_l2206_action_invoke"); + let result = instance.call("ge", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2207 +fn c2195_l2207_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2195_l2207_action_invoke"); + let result = instance.call("ge", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2208 +fn c2196_l2208_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2196_l2208_action_invoke"); + let result = instance.call("ge", &[Value::F64((-1.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2209 +fn c2197_l2209_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2197_l2209_action_invoke"); + let result = instance.call("ge", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2210 +fn c2198_l2210_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2198_l2210_action_invoke"); + let result = instance.call("ge", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2211 +fn c2199_l2211_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2199_l2211_action_invoke"); + let result = instance.call("ge", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2212 +fn c2200_l2212_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2200_l2212_action_invoke"); + let result = instance.call("ge", &[Value::F64((1.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2213 +fn c2201_l2213_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2201_l2213_action_invoke"); + let result = instance.call("ge", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2214 +fn c2202_l2214_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2202_l2214_action_invoke"); + let result = instance.call("ge", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2215 +fn c2203_l2215_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2203_l2215_action_invoke"); + let result = instance.call("ge", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2216 +fn c2204_l2216_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2204_l2216_action_invoke"); + let result = instance.call("ge", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2217 +fn c2205_l2217_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2205_l2217_action_invoke"); + let result = instance.call("ge", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2218 +fn c2206_l2218_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2206_l2218_action_invoke"); + let result = instance.call("ge", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2219 +fn c2207_l2219_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2207_l2219_action_invoke"); + let result = instance.call("ge", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2220 +fn c2208_l2220_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2208_l2220_action_invoke"); + let result = instance.call("ge", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2221 +fn c2209_l2221_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2209_l2221_action_invoke"); + let result = instance.call("ge", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2222 +fn c2210_l2222_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2210_l2222_action_invoke"); + let result = instance.call("ge", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2223 +fn c2211_l2223_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2211_l2223_action_invoke"); + let result = instance.call("ge", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2224 +fn c2212_l2224_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2212_l2224_action_invoke"); + let result = instance.call("ge", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2225 +fn c2213_l2225_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2213_l2225_action_invoke"); + let result = instance.call("ge", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2226 +fn c2214_l2226_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2214_l2226_action_invoke"); + let result = instance.call("ge", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2227 +fn c2215_l2227_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2215_l2227_action_invoke"); + let result = instance.call("ge", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2228 +fn c2216_l2228_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2216_l2228_action_invoke"); + let result = instance.call("ge", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2229 +fn c2217_l2229_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2217_l2229_action_invoke"); + let result = instance.call("ge", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2230 +fn c2218_l2230_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2218_l2230_action_invoke"); + let result = instance.call("ge", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2231 +fn c2219_l2231_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2219_l2231_action_invoke"); + let result = instance.call("ge", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2232 +fn c2220_l2232_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2220_l2232_action_invoke"); + let result = instance.call("ge", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2233 +fn c2221_l2233_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2221_l2233_action_invoke"); + let result = instance.call("ge", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2234 +fn c2222_l2234_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2222_l2234_action_invoke"); + let result = instance.call("ge", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2235 +fn c2223_l2235_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2223_l2235_action_invoke"); + let result = instance.call("ge", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2236 +fn c2224_l2236_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2224_l2236_action_invoke"); + let result = instance.call("ge", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2237 +fn c2225_l2237_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2225_l2237_action_invoke"); + let result = instance.call("ge", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2238 +fn c2226_l2238_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2226_l2238_action_invoke"); + let result = instance.call("ge", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2239 +fn c2227_l2239_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2227_l2239_action_invoke"); + let result = instance.call("ge", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2240 +fn c2228_l2240_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2228_l2240_action_invoke"); + let result = instance.call("ge", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2241 +fn c2229_l2241_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2229_l2241_action_invoke"); + let result = instance.call("ge", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2242 +fn c2230_l2242_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2230_l2242_action_invoke"); + let result = instance.call("ge", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2243 +fn c2231_l2243_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2231_l2243_action_invoke"); + let result = instance.call("ge", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2244 +fn c2232_l2244_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2232_l2244_action_invoke"); + let result = instance.call("ge", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2245 +fn c2233_l2245_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2233_l2245_action_invoke"); + let result = instance.call("ge", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2246 +fn c2234_l2246_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2234_l2246_action_invoke"); + let result = instance.call("ge", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2247 +fn c2235_l2247_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2235_l2247_action_invoke"); + let result = instance.call("ge", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2248 +fn c2236_l2248_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2236_l2248_action_invoke"); + let result = instance.call("ge", &[Value::F64((-6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2249 +fn c2237_l2249_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2237_l2249_action_invoke"); + let result = instance.call("ge", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2250 +fn c2238_l2250_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2238_l2250_action_invoke"); + let result = instance.call("ge", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2251 +fn c2239_l2251_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2239_l2251_action_invoke"); + let result = instance.call("ge", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2252 +fn c2240_l2252_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2240_l2252_action_invoke"); + let result = instance.call("ge", &[Value::F64((6.283185307179586f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2253 +fn c2241_l2253_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2241_l2253_action_invoke"); + let result = instance.call("ge", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2254 +fn c2242_l2254_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2242_l2254_action_invoke"); + let result = instance.call("ge", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2255 +fn c2243_l2255_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2243_l2255_action_invoke"); + let result = instance.call("ge", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2256 +fn c2244_l2256_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2244_l2256_action_invoke"); + let result = instance.call("ge", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2257 +fn c2245_l2257_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2245_l2257_action_invoke"); + let result = instance.call("ge", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2258 +fn c2246_l2258_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2246_l2258_action_invoke"); + let result = instance.call("ge", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2259 +fn c2247_l2259_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2247_l2259_action_invoke"); + let result = instance.call("ge", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2260 +fn c2248_l2260_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2248_l2260_action_invoke"); + let result = instance.call("ge", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2261 +fn c2249_l2261_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2249_l2261_action_invoke"); + let result = instance.call("ge", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2262 +fn c2250_l2262_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2250_l2262_action_invoke"); + let result = instance.call("ge", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2263 +fn c2251_l2263_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2251_l2263_action_invoke"); + let result = instance.call("ge", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2264 +fn c2252_l2264_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2252_l2264_action_invoke"); + let result = instance.call("ge", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2265 +fn c2253_l2265_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2253_l2265_action_invoke"); + let result = instance.call("ge", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2266 +fn c2254_l2266_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2254_l2266_action_invoke"); + let result = instance.call("ge", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2267 +fn c2255_l2267_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2255_l2267_action_invoke"); + let result = instance.call("ge", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2268 +fn c2256_l2268_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2256_l2268_action_invoke"); + let result = instance.call("ge", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2269 +fn c2257_l2269_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2257_l2269_action_invoke"); + let result = instance.call("ge", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2270 +fn c2258_l2270_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2258_l2270_action_invoke"); + let result = instance.call("ge", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2271 +fn c2259_l2271_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2259_l2271_action_invoke"); + let result = instance.call("ge", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2272 +fn c2260_l2272_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2260_l2272_action_invoke"); + let result = instance.call("ge", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2273 +fn c2261_l2273_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2261_l2273_action_invoke"); + let result = instance.call("ge", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2274 +fn c2262_l2274_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2262_l2274_action_invoke"); + let result = instance.call("ge", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2275 +fn c2263_l2275_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2263_l2275_action_invoke"); + let result = instance.call("ge", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2276 +fn c2264_l2276_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2264_l2276_action_invoke"); + let result = instance.call("ge", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2277 +fn c2265_l2277_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2265_l2277_action_invoke"); + let result = instance.call("ge", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2278 +fn c2266_l2278_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2266_l2278_action_invoke"); + let result = instance.call("ge", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2279 +fn c2267_l2279_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2267_l2279_action_invoke"); + let result = instance.call("ge", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2280 +fn c2268_l2280_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2268_l2280_action_invoke"); + let result = instance.call("ge", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2281 +fn c2269_l2281_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2269_l2281_action_invoke"); + let result = instance.call("ge", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2282 +fn c2270_l2282_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2270_l2282_action_invoke"); + let result = instance.call("ge", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2283 +fn c2271_l2283_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2271_l2283_action_invoke"); + let result = instance.call("ge", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2284 +fn c2272_l2284_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2272_l2284_action_invoke"); + let result = instance.call("ge", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2285 +fn c2273_l2285_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2273_l2285_action_invoke"); + let result = instance.call("ge", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2286 +fn c2274_l2286_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2274_l2286_action_invoke"); + let result = instance.call("ge", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2287 +fn c2275_l2287_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2275_l2287_action_invoke"); + let result = instance.call("ge", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2288 +fn c2276_l2288_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2276_l2288_action_invoke"); + let result = instance.call("ge", &[Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2289 +fn c2277_l2289_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2277_l2289_action_invoke"); + let result = instance.call("ge", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2290 +fn c2278_l2290_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2278_l2290_action_invoke"); + let result = instance.call("ge", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2291 +fn c2279_l2291_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2279_l2291_action_invoke"); + let result = instance.call("ge", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2292 +fn c2280_l2292_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2280_l2292_action_invoke"); + let result = instance.call("ge", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2293 +fn c2281_l2293_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2281_l2293_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2294 +fn c2282_l2294_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2282_l2294_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2295 +fn c2283_l2295_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2283_l2295_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2296 +fn c2284_l2296_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2284_l2296_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2297 +fn c2285_l2297_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2285_l2297_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2298 +fn c2286_l2298_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2286_l2298_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2299 +fn c2287_l2299_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2287_l2299_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2300 +fn c2288_l2300_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2288_l2300_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2301 +fn c2289_l2301_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2289_l2301_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2302 +fn c2290_l2302_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2290_l2302_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2303 +fn c2291_l2303_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2291_l2303_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2304 +fn c2292_l2304_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2292_l2304_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2305 +fn c2293_l2305_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2293_l2305_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2306 +fn c2294_l2306_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2294_l2306_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2307 +fn c2295_l2307_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2295_l2307_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2308 +fn c2296_l2308_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2296_l2308_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2309 +fn c2297_l2309_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2297_l2309_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2310 +fn c2298_l2310_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2298_l2310_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2311 +fn c2299_l2311_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2299_l2311_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2312 +fn c2300_l2312_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2300_l2312_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2313 +fn c2301_l2313_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2301_l2313_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2314 +fn c2302_l2314_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2302_l2314_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2315 +fn c2303_l2315_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2303_l2315_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2316 +fn c2304_l2316_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2304_l2316_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2317 +fn c2305_l2317_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2305_l2317_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2318 +fn c2306_l2318_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2306_l2318_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2319 +fn c2307_l2319_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2307_l2319_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2320 +fn c2308_l2320_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2308_l2320_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::INFINITY.to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2321 +fn c2309_l2321_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2309_l2321_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2322 +fn c2310_l2322_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2310_l2322_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2323 +fn c2311_l2323_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2311_l2323_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2324 +fn c2312_l2324_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2312_l2324_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2325 +fn c2313_l2325_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2313_l2325_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2326 +fn c2314_l2326_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2314_l2326_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2327 +fn c2315_l2327_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2315_l2327_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2328 +fn c2316_l2328_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2316_l2328_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2329 +fn c2317_l2329_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2317_l2329_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2330 +fn c2318_l2330_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2318_l2330_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2331 +fn c2319_l2331_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2319_l2331_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2332 +fn c2320_l2332_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2320_l2332_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2333 +fn c2321_l2333_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2321_l2333_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2334 +fn c2322_l2334_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2322_l2334_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2335 +fn c2323_l2335_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2323_l2335_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2336 +fn c2324_l2336_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2324_l2336_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2337 +fn c2325_l2337_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2325_l2337_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2338 +fn c2326_l2338_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2326_l2338_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2339 +fn c2327_l2339_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2327_l2339_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2340 +fn c2328_l2340_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2328_l2340_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2341 +fn c2329_l2341_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2329_l2341_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2342 +fn c2330_l2342_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2330_l2342_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2343 +fn c2331_l2343_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2331_l2343_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2344 +fn c2332_l2344_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2332_l2344_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2345 +fn c2333_l2345_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2333_l2345_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2346 +fn c2334_l2346_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2334_l2346_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2347 +fn c2335_l2347_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2335_l2347_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2348 +fn c2336_l2348_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2336_l2348_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2349 +fn c2337_l2349_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2337_l2349_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2350 +fn c2338_l2350_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2338_l2350_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2351 +fn c2339_l2351_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2339_l2351_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2352 +fn c2340_l2352_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2340_l2352_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2353 +fn c2341_l2353_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2341_l2353_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2354 +fn c2342_l2354_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2342_l2354_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2355 +fn c2343_l2355_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2343_l2355_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2356 +fn c2344_l2356_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2344_l2356_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2357 +fn c2345_l2357_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2345_l2357_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2358 +fn c2346_l2358_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2346_l2358_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2359 +fn c2347_l2359_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2347_l2359_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2360 +fn c2348_l2360_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2348_l2360_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2361 +fn c2349_l2361_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2349_l2361_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2362 +fn c2350_l2362_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2350_l2362_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2363 +fn c2351_l2363_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2351_l2363_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2364 +fn c2352_l2364_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2352_l2364_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2365 +fn c2353_l2365_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2353_l2365_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2366 +fn c2354_l2366_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2354_l2366_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2367 +fn c2355_l2367_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2355_l2367_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2368 +fn c2356_l2368_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2356_l2368_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2369 +fn c2357_l2369_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2357_l2369_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2370 +fn c2358_l2370_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2358_l2370_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2371 +fn c2359_l2371_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2359_l2371_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2372 +fn c2360_l2372_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2360_l2372_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2373 +fn c2361_l2373_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2361_l2373_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2374 +fn c2362_l2374_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2362_l2374_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2375 +fn c2363_l2375_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2363_l2375_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2376 +fn c2364_l2376_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2364_l2376_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2377 +fn c2365_l2377_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2365_l2377_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2378 +fn c2366_l2378_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2366_l2378_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2379 +fn c2367_l2379_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2367_l2379_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2380 +fn c2368_l2380_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2368_l2380_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((6.283185307179586f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2381 +fn c2369_l2381_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2369_l2381_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2382 +fn c2370_l2382_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2370_l2382_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2383 +fn c2371_l2383_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2371_l2383_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2384 +fn c2372_l2384_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2372_l2384_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2385 +fn c2373_l2385_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2373_l2385_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2386 +fn c2374_l2386_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2374_l2386_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2387 +fn c2375_l2387_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2375_l2387_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2388 +fn c2376_l2388_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2376_l2388_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2389 +fn c2377_l2389_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2377_l2389_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2390 +fn c2378_l2390_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2378_l2390_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2391 +fn c2379_l2391_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2379_l2391_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2392 +fn c2380_l2392_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2380_l2392_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2393 +fn c2381_l2393_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2381_l2393_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2394 +fn c2382_l2394_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2382_l2394_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2395 +fn c2383_l2395_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2383_l2395_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2396 +fn c2384_l2396_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2384_l2396_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2397 +fn c2385_l2397_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2385_l2397_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2398 +fn c2386_l2398_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2386_l2398_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2399 +fn c2387_l2399_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2387_l2399_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2400 +fn c2388_l2400_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2388_l2400_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2401 +fn c2389_l2401_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2389_l2401_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2402 +fn c2390_l2402_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2390_l2402_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2403 +fn c2391_l2403_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2391_l2403_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18444492273895866368) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2404 +fn c2392_l2404_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2392_l2404_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(18443366373989023744) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2405 +fn c2393_l2405_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2393_l2405_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2406 +fn c2394_l2406_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2394_l2406_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2407 +fn c2395_l2407_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2395_l2407_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2408 +fn c2396_l2408_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2396_l2408_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(18443366373989023744) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2409 +fn c2397_l2409_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2397_l2409_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2410 +fn c2398_l2410_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2398_l2410_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2411 +fn c2399_l2411_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2399_l2411_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2412 +fn c2400_l2412_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2400_l2412_action_invoke"); + let result = instance.call("ge", &[Value::F64(f64::from_bits(9219994337134247936) as u64), Value::F64(f64::from_bits(9219994337134247936) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l13_action_invoke(&mut instance); + c2_l14_action_invoke(&mut instance); + c3_l15_action_invoke(&mut instance); + c4_l16_action_invoke(&mut instance); + c5_l17_action_invoke(&mut instance); + c6_l18_action_invoke(&mut instance); + c7_l19_action_invoke(&mut instance); + c8_l20_action_invoke(&mut instance); + c9_l21_action_invoke(&mut instance); + c10_l22_action_invoke(&mut instance); + c11_l23_action_invoke(&mut instance); + c12_l24_action_invoke(&mut instance); + c13_l25_action_invoke(&mut instance); + c14_l26_action_invoke(&mut instance); + c15_l27_action_invoke(&mut instance); + c16_l28_action_invoke(&mut instance); + c17_l29_action_invoke(&mut instance); + c18_l30_action_invoke(&mut instance); + c19_l31_action_invoke(&mut instance); + c20_l32_action_invoke(&mut instance); + c21_l33_action_invoke(&mut instance); + c22_l34_action_invoke(&mut instance); + c23_l35_action_invoke(&mut instance); + c24_l36_action_invoke(&mut instance); + c25_l37_action_invoke(&mut instance); + c26_l38_action_invoke(&mut instance); + c27_l39_action_invoke(&mut instance); + c28_l40_action_invoke(&mut instance); + c29_l41_action_invoke(&mut instance); + c30_l42_action_invoke(&mut instance); + c31_l43_action_invoke(&mut instance); + c32_l44_action_invoke(&mut instance); + c33_l45_action_invoke(&mut instance); + c34_l46_action_invoke(&mut instance); + c35_l47_action_invoke(&mut instance); + c36_l48_action_invoke(&mut instance); + c37_l49_action_invoke(&mut instance); + c38_l50_action_invoke(&mut instance); + c39_l51_action_invoke(&mut instance); + c40_l52_action_invoke(&mut instance); + c41_l53_action_invoke(&mut instance); + c42_l54_action_invoke(&mut instance); + c43_l55_action_invoke(&mut instance); + c44_l56_action_invoke(&mut instance); + c45_l57_action_invoke(&mut instance); + c46_l58_action_invoke(&mut instance); + c47_l59_action_invoke(&mut instance); + c48_l60_action_invoke(&mut instance); + c49_l61_action_invoke(&mut instance); + c50_l62_action_invoke(&mut instance); + c51_l63_action_invoke(&mut instance); + c52_l64_action_invoke(&mut instance); + c53_l65_action_invoke(&mut instance); + c54_l66_action_invoke(&mut instance); + c55_l67_action_invoke(&mut instance); + c56_l68_action_invoke(&mut instance); + c57_l69_action_invoke(&mut instance); + c58_l70_action_invoke(&mut instance); + c59_l71_action_invoke(&mut instance); + c60_l72_action_invoke(&mut instance); + c61_l73_action_invoke(&mut instance); + c62_l74_action_invoke(&mut instance); + c63_l75_action_invoke(&mut instance); + c64_l76_action_invoke(&mut instance); + c65_l77_action_invoke(&mut instance); + c66_l78_action_invoke(&mut instance); + c67_l79_action_invoke(&mut instance); + c68_l80_action_invoke(&mut instance); + c69_l81_action_invoke(&mut instance); + c70_l82_action_invoke(&mut instance); + c71_l83_action_invoke(&mut instance); + c72_l84_action_invoke(&mut instance); + c73_l85_action_invoke(&mut instance); + c74_l86_action_invoke(&mut instance); + c75_l87_action_invoke(&mut instance); + c76_l88_action_invoke(&mut instance); + c77_l89_action_invoke(&mut instance); + c78_l90_action_invoke(&mut instance); + c79_l91_action_invoke(&mut instance); + c80_l92_action_invoke(&mut instance); + c81_l93_action_invoke(&mut instance); + c82_l94_action_invoke(&mut instance); + c83_l95_action_invoke(&mut instance); + c84_l96_action_invoke(&mut instance); + c85_l97_action_invoke(&mut instance); + c86_l98_action_invoke(&mut instance); + c87_l99_action_invoke(&mut instance); + c88_l100_action_invoke(&mut instance); + c89_l101_action_invoke(&mut instance); + c90_l102_action_invoke(&mut instance); + c91_l103_action_invoke(&mut instance); + c92_l104_action_invoke(&mut instance); + c93_l105_action_invoke(&mut instance); + c94_l106_action_invoke(&mut instance); + c95_l107_action_invoke(&mut instance); + c96_l108_action_invoke(&mut instance); + c97_l109_action_invoke(&mut instance); + c98_l110_action_invoke(&mut instance); + c99_l111_action_invoke(&mut instance); + c100_l112_action_invoke(&mut instance); + c101_l113_action_invoke(&mut instance); + c102_l114_action_invoke(&mut instance); + c103_l115_action_invoke(&mut instance); + c104_l116_action_invoke(&mut instance); + c105_l117_action_invoke(&mut instance); + c106_l118_action_invoke(&mut instance); + c107_l119_action_invoke(&mut instance); + c108_l120_action_invoke(&mut instance); + c109_l121_action_invoke(&mut instance); + c110_l122_action_invoke(&mut instance); + c111_l123_action_invoke(&mut instance); + c112_l124_action_invoke(&mut instance); + c113_l125_action_invoke(&mut instance); + c114_l126_action_invoke(&mut instance); + c115_l127_action_invoke(&mut instance); + c116_l128_action_invoke(&mut instance); + c117_l129_action_invoke(&mut instance); + c118_l130_action_invoke(&mut instance); + c119_l131_action_invoke(&mut instance); + c120_l132_action_invoke(&mut instance); + c121_l133_action_invoke(&mut instance); + c122_l134_action_invoke(&mut instance); + c123_l135_action_invoke(&mut instance); + c124_l136_action_invoke(&mut instance); + c125_l137_action_invoke(&mut instance); + c126_l138_action_invoke(&mut instance); + c127_l139_action_invoke(&mut instance); + c128_l140_action_invoke(&mut instance); + c129_l141_action_invoke(&mut instance); + c130_l142_action_invoke(&mut instance); + c131_l143_action_invoke(&mut instance); + c132_l144_action_invoke(&mut instance); + c133_l145_action_invoke(&mut instance); + c134_l146_action_invoke(&mut instance); + c135_l147_action_invoke(&mut instance); + c136_l148_action_invoke(&mut instance); + c137_l149_action_invoke(&mut instance); + c138_l150_action_invoke(&mut instance); + c139_l151_action_invoke(&mut instance); + c140_l152_action_invoke(&mut instance); + c141_l153_action_invoke(&mut instance); + c142_l154_action_invoke(&mut instance); + c143_l155_action_invoke(&mut instance); + c144_l156_action_invoke(&mut instance); + c145_l157_action_invoke(&mut instance); + c146_l158_action_invoke(&mut instance); + c147_l159_action_invoke(&mut instance); + c148_l160_action_invoke(&mut instance); + c149_l161_action_invoke(&mut instance); + c150_l162_action_invoke(&mut instance); + c151_l163_action_invoke(&mut instance); + c152_l164_action_invoke(&mut instance); + c153_l165_action_invoke(&mut instance); + c154_l166_action_invoke(&mut instance); + c155_l167_action_invoke(&mut instance); + c156_l168_action_invoke(&mut instance); + c157_l169_action_invoke(&mut instance); + c158_l170_action_invoke(&mut instance); + c159_l171_action_invoke(&mut instance); + c160_l172_action_invoke(&mut instance); + c161_l173_action_invoke(&mut instance); + c162_l174_action_invoke(&mut instance); + c163_l175_action_invoke(&mut instance); + c164_l176_action_invoke(&mut instance); + c165_l177_action_invoke(&mut instance); + c166_l178_action_invoke(&mut instance); + c167_l179_action_invoke(&mut instance); + c168_l180_action_invoke(&mut instance); + c169_l181_action_invoke(&mut instance); + c170_l182_action_invoke(&mut instance); + c171_l183_action_invoke(&mut instance); + c172_l184_action_invoke(&mut instance); + c173_l185_action_invoke(&mut instance); + c174_l186_action_invoke(&mut instance); + c175_l187_action_invoke(&mut instance); + c176_l188_action_invoke(&mut instance); + c177_l189_action_invoke(&mut instance); + c178_l190_action_invoke(&mut instance); + c179_l191_action_invoke(&mut instance); + c180_l192_action_invoke(&mut instance); + c181_l193_action_invoke(&mut instance); + c182_l194_action_invoke(&mut instance); + c183_l195_action_invoke(&mut instance); + c184_l196_action_invoke(&mut instance); + c185_l197_action_invoke(&mut instance); + c186_l198_action_invoke(&mut instance); + c187_l199_action_invoke(&mut instance); + c188_l200_action_invoke(&mut instance); + c189_l201_action_invoke(&mut instance); + c190_l202_action_invoke(&mut instance); + c191_l203_action_invoke(&mut instance); + c192_l204_action_invoke(&mut instance); + c193_l205_action_invoke(&mut instance); + c194_l206_action_invoke(&mut instance); + c195_l207_action_invoke(&mut instance); + c196_l208_action_invoke(&mut instance); + c197_l209_action_invoke(&mut instance); + c198_l210_action_invoke(&mut instance); + c199_l211_action_invoke(&mut instance); + c200_l212_action_invoke(&mut instance); + c201_l213_action_invoke(&mut instance); + c202_l214_action_invoke(&mut instance); + c203_l215_action_invoke(&mut instance); + c204_l216_action_invoke(&mut instance); + c205_l217_action_invoke(&mut instance); + c206_l218_action_invoke(&mut instance); + c207_l219_action_invoke(&mut instance); + c208_l220_action_invoke(&mut instance); + c209_l221_action_invoke(&mut instance); + c210_l222_action_invoke(&mut instance); + c211_l223_action_invoke(&mut instance); + c212_l224_action_invoke(&mut instance); + c213_l225_action_invoke(&mut instance); + c214_l226_action_invoke(&mut instance); + c215_l227_action_invoke(&mut instance); + c216_l228_action_invoke(&mut instance); + c217_l229_action_invoke(&mut instance); + c218_l230_action_invoke(&mut instance); + c219_l231_action_invoke(&mut instance); + c220_l232_action_invoke(&mut instance); + c221_l233_action_invoke(&mut instance); + c222_l234_action_invoke(&mut instance); + c223_l235_action_invoke(&mut instance); + c224_l236_action_invoke(&mut instance); + c225_l237_action_invoke(&mut instance); + c226_l238_action_invoke(&mut instance); + c227_l239_action_invoke(&mut instance); + c228_l240_action_invoke(&mut instance); + c229_l241_action_invoke(&mut instance); + c230_l242_action_invoke(&mut instance); + c231_l243_action_invoke(&mut instance); + c232_l244_action_invoke(&mut instance); + c233_l245_action_invoke(&mut instance); + c234_l246_action_invoke(&mut instance); + c235_l247_action_invoke(&mut instance); + c236_l248_action_invoke(&mut instance); + c237_l249_action_invoke(&mut instance); + c238_l250_action_invoke(&mut instance); + c239_l251_action_invoke(&mut instance); + c240_l252_action_invoke(&mut instance); + c241_l253_action_invoke(&mut instance); + c242_l254_action_invoke(&mut instance); + c243_l255_action_invoke(&mut instance); + c244_l256_action_invoke(&mut instance); + c245_l257_action_invoke(&mut instance); + c246_l258_action_invoke(&mut instance); + c247_l259_action_invoke(&mut instance); + c248_l260_action_invoke(&mut instance); + c249_l261_action_invoke(&mut instance); + c250_l262_action_invoke(&mut instance); + c251_l263_action_invoke(&mut instance); + c252_l264_action_invoke(&mut instance); + c253_l265_action_invoke(&mut instance); + c254_l266_action_invoke(&mut instance); + c255_l267_action_invoke(&mut instance); + c256_l268_action_invoke(&mut instance); + c257_l269_action_invoke(&mut instance); + c258_l270_action_invoke(&mut instance); + c259_l271_action_invoke(&mut instance); + c260_l272_action_invoke(&mut instance); + c261_l273_action_invoke(&mut instance); + c262_l274_action_invoke(&mut instance); + c263_l275_action_invoke(&mut instance); + c264_l276_action_invoke(&mut instance); + c265_l277_action_invoke(&mut instance); + c266_l278_action_invoke(&mut instance); + c267_l279_action_invoke(&mut instance); + c268_l280_action_invoke(&mut instance); + c269_l281_action_invoke(&mut instance); + c270_l282_action_invoke(&mut instance); + c271_l283_action_invoke(&mut instance); + c272_l284_action_invoke(&mut instance); + c273_l285_action_invoke(&mut instance); + c274_l286_action_invoke(&mut instance); + c275_l287_action_invoke(&mut instance); + c276_l288_action_invoke(&mut instance); + c277_l289_action_invoke(&mut instance); + c278_l290_action_invoke(&mut instance); + c279_l291_action_invoke(&mut instance); + c280_l292_action_invoke(&mut instance); + c281_l293_action_invoke(&mut instance); + c282_l294_action_invoke(&mut instance); + c283_l295_action_invoke(&mut instance); + c284_l296_action_invoke(&mut instance); + c285_l297_action_invoke(&mut instance); + c286_l298_action_invoke(&mut instance); + c287_l299_action_invoke(&mut instance); + c288_l300_action_invoke(&mut instance); + c289_l301_action_invoke(&mut instance); + c290_l302_action_invoke(&mut instance); + c291_l303_action_invoke(&mut instance); + c292_l304_action_invoke(&mut instance); + c293_l305_action_invoke(&mut instance); + c294_l306_action_invoke(&mut instance); + c295_l307_action_invoke(&mut instance); + c296_l308_action_invoke(&mut instance); + c297_l309_action_invoke(&mut instance); + c298_l310_action_invoke(&mut instance); + c299_l311_action_invoke(&mut instance); + c300_l312_action_invoke(&mut instance); + c301_l313_action_invoke(&mut instance); + c302_l314_action_invoke(&mut instance); + c303_l315_action_invoke(&mut instance); + c304_l316_action_invoke(&mut instance); + c305_l317_action_invoke(&mut instance); + c306_l318_action_invoke(&mut instance); + c307_l319_action_invoke(&mut instance); + c308_l320_action_invoke(&mut instance); + c309_l321_action_invoke(&mut instance); + c310_l322_action_invoke(&mut instance); + c311_l323_action_invoke(&mut instance); + c312_l324_action_invoke(&mut instance); + c313_l325_action_invoke(&mut instance); + c314_l326_action_invoke(&mut instance); + c315_l327_action_invoke(&mut instance); + c316_l328_action_invoke(&mut instance); + c317_l329_action_invoke(&mut instance); + c318_l330_action_invoke(&mut instance); + c319_l331_action_invoke(&mut instance); + c320_l332_action_invoke(&mut instance); + c321_l333_action_invoke(&mut instance); + c322_l334_action_invoke(&mut instance); + c323_l335_action_invoke(&mut instance); + c324_l336_action_invoke(&mut instance); + c325_l337_action_invoke(&mut instance); + c326_l338_action_invoke(&mut instance); + c327_l339_action_invoke(&mut instance); + c328_l340_action_invoke(&mut instance); + c329_l341_action_invoke(&mut instance); + c330_l342_action_invoke(&mut instance); + c331_l343_action_invoke(&mut instance); + c332_l344_action_invoke(&mut instance); + c333_l345_action_invoke(&mut instance); + c334_l346_action_invoke(&mut instance); + c335_l347_action_invoke(&mut instance); + c336_l348_action_invoke(&mut instance); + c337_l349_action_invoke(&mut instance); + c338_l350_action_invoke(&mut instance); + c339_l351_action_invoke(&mut instance); + c340_l352_action_invoke(&mut instance); + c341_l353_action_invoke(&mut instance); + c342_l354_action_invoke(&mut instance); + c343_l355_action_invoke(&mut instance); + c344_l356_action_invoke(&mut instance); + c345_l357_action_invoke(&mut instance); + c346_l358_action_invoke(&mut instance); + c347_l359_action_invoke(&mut instance); + c348_l360_action_invoke(&mut instance); + c349_l361_action_invoke(&mut instance); + c350_l362_action_invoke(&mut instance); + c351_l363_action_invoke(&mut instance); + c352_l364_action_invoke(&mut instance); + c353_l365_action_invoke(&mut instance); + c354_l366_action_invoke(&mut instance); + c355_l367_action_invoke(&mut instance); + c356_l368_action_invoke(&mut instance); + c357_l369_action_invoke(&mut instance); + c358_l370_action_invoke(&mut instance); + c359_l371_action_invoke(&mut instance); + c360_l372_action_invoke(&mut instance); + c361_l373_action_invoke(&mut instance); + c362_l374_action_invoke(&mut instance); + c363_l375_action_invoke(&mut instance); + c364_l376_action_invoke(&mut instance); + c365_l377_action_invoke(&mut instance); + c366_l378_action_invoke(&mut instance); + c367_l379_action_invoke(&mut instance); + c368_l380_action_invoke(&mut instance); + c369_l381_action_invoke(&mut instance); + c370_l382_action_invoke(&mut instance); + c371_l383_action_invoke(&mut instance); + c372_l384_action_invoke(&mut instance); + c373_l385_action_invoke(&mut instance); + c374_l386_action_invoke(&mut instance); + c375_l387_action_invoke(&mut instance); + c376_l388_action_invoke(&mut instance); + c377_l389_action_invoke(&mut instance); + c378_l390_action_invoke(&mut instance); + c379_l391_action_invoke(&mut instance); + c380_l392_action_invoke(&mut instance); + c381_l393_action_invoke(&mut instance); + c382_l394_action_invoke(&mut instance); + c383_l395_action_invoke(&mut instance); + c384_l396_action_invoke(&mut instance); + c385_l397_action_invoke(&mut instance); + c386_l398_action_invoke(&mut instance); + c387_l399_action_invoke(&mut instance); + c388_l400_action_invoke(&mut instance); + c389_l401_action_invoke(&mut instance); + c390_l402_action_invoke(&mut instance); + c391_l403_action_invoke(&mut instance); + c392_l404_action_invoke(&mut instance); + c393_l405_action_invoke(&mut instance); + c394_l406_action_invoke(&mut instance); + c395_l407_action_invoke(&mut instance); + c396_l408_action_invoke(&mut instance); + c397_l409_action_invoke(&mut instance); + c398_l410_action_invoke(&mut instance); + c399_l411_action_invoke(&mut instance); + c400_l412_action_invoke(&mut instance); + c401_l413_action_invoke(&mut instance); + c402_l414_action_invoke(&mut instance); + c403_l415_action_invoke(&mut instance); + c404_l416_action_invoke(&mut instance); + c405_l417_action_invoke(&mut instance); + c406_l418_action_invoke(&mut instance); + c407_l419_action_invoke(&mut instance); + c408_l420_action_invoke(&mut instance); + c409_l421_action_invoke(&mut instance); + c410_l422_action_invoke(&mut instance); + c411_l423_action_invoke(&mut instance); + c412_l424_action_invoke(&mut instance); + c413_l425_action_invoke(&mut instance); + c414_l426_action_invoke(&mut instance); + c415_l427_action_invoke(&mut instance); + c416_l428_action_invoke(&mut instance); + c417_l429_action_invoke(&mut instance); + c418_l430_action_invoke(&mut instance); + c419_l431_action_invoke(&mut instance); + c420_l432_action_invoke(&mut instance); + c421_l433_action_invoke(&mut instance); + c422_l434_action_invoke(&mut instance); + c423_l435_action_invoke(&mut instance); + c424_l436_action_invoke(&mut instance); + c425_l437_action_invoke(&mut instance); + c426_l438_action_invoke(&mut instance); + c427_l439_action_invoke(&mut instance); + c428_l440_action_invoke(&mut instance); + c429_l441_action_invoke(&mut instance); + c430_l442_action_invoke(&mut instance); + c431_l443_action_invoke(&mut instance); + c432_l444_action_invoke(&mut instance); + c433_l445_action_invoke(&mut instance); + c434_l446_action_invoke(&mut instance); + c435_l447_action_invoke(&mut instance); + c436_l448_action_invoke(&mut instance); + c437_l449_action_invoke(&mut instance); + c438_l450_action_invoke(&mut instance); + c439_l451_action_invoke(&mut instance); + c440_l452_action_invoke(&mut instance); + c441_l453_action_invoke(&mut instance); + c442_l454_action_invoke(&mut instance); + c443_l455_action_invoke(&mut instance); + c444_l456_action_invoke(&mut instance); + c445_l457_action_invoke(&mut instance); + c446_l458_action_invoke(&mut instance); + c447_l459_action_invoke(&mut instance); + c448_l460_action_invoke(&mut instance); + c449_l461_action_invoke(&mut instance); + c450_l462_action_invoke(&mut instance); + c451_l463_action_invoke(&mut instance); + c452_l464_action_invoke(&mut instance); + c453_l465_action_invoke(&mut instance); + c454_l466_action_invoke(&mut instance); + c455_l467_action_invoke(&mut instance); + c456_l468_action_invoke(&mut instance); + c457_l469_action_invoke(&mut instance); + c458_l470_action_invoke(&mut instance); + c459_l471_action_invoke(&mut instance); + c460_l472_action_invoke(&mut instance); + c461_l473_action_invoke(&mut instance); + c462_l474_action_invoke(&mut instance); + c463_l475_action_invoke(&mut instance); + c464_l476_action_invoke(&mut instance); + c465_l477_action_invoke(&mut instance); + c466_l478_action_invoke(&mut instance); + c467_l479_action_invoke(&mut instance); + c468_l480_action_invoke(&mut instance); + c469_l481_action_invoke(&mut instance); + c470_l482_action_invoke(&mut instance); + c471_l483_action_invoke(&mut instance); + c472_l484_action_invoke(&mut instance); + c473_l485_action_invoke(&mut instance); + c474_l486_action_invoke(&mut instance); + c475_l487_action_invoke(&mut instance); + c476_l488_action_invoke(&mut instance); + c477_l489_action_invoke(&mut instance); + c478_l490_action_invoke(&mut instance); + c479_l491_action_invoke(&mut instance); + c480_l492_action_invoke(&mut instance); + c481_l493_action_invoke(&mut instance); + c482_l494_action_invoke(&mut instance); + c483_l495_action_invoke(&mut instance); + c484_l496_action_invoke(&mut instance); + c485_l497_action_invoke(&mut instance); + c486_l498_action_invoke(&mut instance); + c487_l499_action_invoke(&mut instance); + c488_l500_action_invoke(&mut instance); + c489_l501_action_invoke(&mut instance); + c490_l502_action_invoke(&mut instance); + c491_l503_action_invoke(&mut instance); + c492_l504_action_invoke(&mut instance); + c493_l505_action_invoke(&mut instance); + c494_l506_action_invoke(&mut instance); + c495_l507_action_invoke(&mut instance); + c496_l508_action_invoke(&mut instance); + c497_l509_action_invoke(&mut instance); + c498_l510_action_invoke(&mut instance); + c499_l511_action_invoke(&mut instance); + c500_l512_action_invoke(&mut instance); + c501_l513_action_invoke(&mut instance); + c502_l514_action_invoke(&mut instance); + c503_l515_action_invoke(&mut instance); + c504_l516_action_invoke(&mut instance); + c505_l517_action_invoke(&mut instance); + c506_l518_action_invoke(&mut instance); + c507_l519_action_invoke(&mut instance); + c508_l520_action_invoke(&mut instance); + c509_l521_action_invoke(&mut instance); + c510_l522_action_invoke(&mut instance); + c511_l523_action_invoke(&mut instance); + c512_l524_action_invoke(&mut instance); + c513_l525_action_invoke(&mut instance); + c514_l526_action_invoke(&mut instance); + c515_l527_action_invoke(&mut instance); + c516_l528_action_invoke(&mut instance); + c517_l529_action_invoke(&mut instance); + c518_l530_action_invoke(&mut instance); + c519_l531_action_invoke(&mut instance); + c520_l532_action_invoke(&mut instance); + c521_l533_action_invoke(&mut instance); + c522_l534_action_invoke(&mut instance); + c523_l535_action_invoke(&mut instance); + c524_l536_action_invoke(&mut instance); + c525_l537_action_invoke(&mut instance); + c526_l538_action_invoke(&mut instance); + c527_l539_action_invoke(&mut instance); + c528_l540_action_invoke(&mut instance); + c529_l541_action_invoke(&mut instance); + c530_l542_action_invoke(&mut instance); + c531_l543_action_invoke(&mut instance); + c532_l544_action_invoke(&mut instance); + c533_l545_action_invoke(&mut instance); + c534_l546_action_invoke(&mut instance); + c535_l547_action_invoke(&mut instance); + c536_l548_action_invoke(&mut instance); + c537_l549_action_invoke(&mut instance); + c538_l550_action_invoke(&mut instance); + c539_l551_action_invoke(&mut instance); + c540_l552_action_invoke(&mut instance); + c541_l553_action_invoke(&mut instance); + c542_l554_action_invoke(&mut instance); + c543_l555_action_invoke(&mut instance); + c544_l556_action_invoke(&mut instance); + c545_l557_action_invoke(&mut instance); + c546_l558_action_invoke(&mut instance); + c547_l559_action_invoke(&mut instance); + c548_l560_action_invoke(&mut instance); + c549_l561_action_invoke(&mut instance); + c550_l562_action_invoke(&mut instance); + c551_l563_action_invoke(&mut instance); + c552_l564_action_invoke(&mut instance); + c553_l565_action_invoke(&mut instance); + c554_l566_action_invoke(&mut instance); + c555_l567_action_invoke(&mut instance); + c556_l568_action_invoke(&mut instance); + c557_l569_action_invoke(&mut instance); + c558_l570_action_invoke(&mut instance); + c559_l571_action_invoke(&mut instance); + c560_l572_action_invoke(&mut instance); + c561_l573_action_invoke(&mut instance); + c562_l574_action_invoke(&mut instance); + c563_l575_action_invoke(&mut instance); + c564_l576_action_invoke(&mut instance); + c565_l577_action_invoke(&mut instance); + c566_l578_action_invoke(&mut instance); + c567_l579_action_invoke(&mut instance); + c568_l580_action_invoke(&mut instance); + c569_l581_action_invoke(&mut instance); + c570_l582_action_invoke(&mut instance); + c571_l583_action_invoke(&mut instance); + c572_l584_action_invoke(&mut instance); + c573_l585_action_invoke(&mut instance); + c574_l586_action_invoke(&mut instance); + c575_l587_action_invoke(&mut instance); + c576_l588_action_invoke(&mut instance); + c577_l589_action_invoke(&mut instance); + c578_l590_action_invoke(&mut instance); + c579_l591_action_invoke(&mut instance); + c580_l592_action_invoke(&mut instance); + c581_l593_action_invoke(&mut instance); + c582_l594_action_invoke(&mut instance); + c583_l595_action_invoke(&mut instance); + c584_l596_action_invoke(&mut instance); + c585_l597_action_invoke(&mut instance); + c586_l598_action_invoke(&mut instance); + c587_l599_action_invoke(&mut instance); + c588_l600_action_invoke(&mut instance); + c589_l601_action_invoke(&mut instance); + c590_l602_action_invoke(&mut instance); + c591_l603_action_invoke(&mut instance); + c592_l604_action_invoke(&mut instance); + c593_l605_action_invoke(&mut instance); + c594_l606_action_invoke(&mut instance); + c595_l607_action_invoke(&mut instance); + c596_l608_action_invoke(&mut instance); + c597_l609_action_invoke(&mut instance); + c598_l610_action_invoke(&mut instance); + c599_l611_action_invoke(&mut instance); + c600_l612_action_invoke(&mut instance); + c601_l613_action_invoke(&mut instance); + c602_l614_action_invoke(&mut instance); + c603_l615_action_invoke(&mut instance); + c604_l616_action_invoke(&mut instance); + c605_l617_action_invoke(&mut instance); + c606_l618_action_invoke(&mut instance); + c607_l619_action_invoke(&mut instance); + c608_l620_action_invoke(&mut instance); + c609_l621_action_invoke(&mut instance); + c610_l622_action_invoke(&mut instance); + c611_l623_action_invoke(&mut instance); + c612_l624_action_invoke(&mut instance); + c613_l625_action_invoke(&mut instance); + c614_l626_action_invoke(&mut instance); + c615_l627_action_invoke(&mut instance); + c616_l628_action_invoke(&mut instance); + c617_l629_action_invoke(&mut instance); + c618_l630_action_invoke(&mut instance); + c619_l631_action_invoke(&mut instance); + c620_l632_action_invoke(&mut instance); + c621_l633_action_invoke(&mut instance); + c622_l634_action_invoke(&mut instance); + c623_l635_action_invoke(&mut instance); + c624_l636_action_invoke(&mut instance); + c625_l637_action_invoke(&mut instance); + c626_l638_action_invoke(&mut instance); + c627_l639_action_invoke(&mut instance); + c628_l640_action_invoke(&mut instance); + c629_l641_action_invoke(&mut instance); + c630_l642_action_invoke(&mut instance); + c631_l643_action_invoke(&mut instance); + c632_l644_action_invoke(&mut instance); + c633_l645_action_invoke(&mut instance); + c634_l646_action_invoke(&mut instance); + c635_l647_action_invoke(&mut instance); + c636_l648_action_invoke(&mut instance); + c637_l649_action_invoke(&mut instance); + c638_l650_action_invoke(&mut instance); + c639_l651_action_invoke(&mut instance); + c640_l652_action_invoke(&mut instance); + c641_l653_action_invoke(&mut instance); + c642_l654_action_invoke(&mut instance); + c643_l655_action_invoke(&mut instance); + c644_l656_action_invoke(&mut instance); + c645_l657_action_invoke(&mut instance); + c646_l658_action_invoke(&mut instance); + c647_l659_action_invoke(&mut instance); + c648_l660_action_invoke(&mut instance); + c649_l661_action_invoke(&mut instance); + c650_l662_action_invoke(&mut instance); + c651_l663_action_invoke(&mut instance); + c652_l664_action_invoke(&mut instance); + c653_l665_action_invoke(&mut instance); + c654_l666_action_invoke(&mut instance); + c655_l667_action_invoke(&mut instance); + c656_l668_action_invoke(&mut instance); + c657_l669_action_invoke(&mut instance); + c658_l670_action_invoke(&mut instance); + c659_l671_action_invoke(&mut instance); + c660_l672_action_invoke(&mut instance); + c661_l673_action_invoke(&mut instance); + c662_l674_action_invoke(&mut instance); + c663_l675_action_invoke(&mut instance); + c664_l676_action_invoke(&mut instance); + c665_l677_action_invoke(&mut instance); + c666_l678_action_invoke(&mut instance); + c667_l679_action_invoke(&mut instance); + c668_l680_action_invoke(&mut instance); + c669_l681_action_invoke(&mut instance); + c670_l682_action_invoke(&mut instance); + c671_l683_action_invoke(&mut instance); + c672_l684_action_invoke(&mut instance); + c673_l685_action_invoke(&mut instance); + c674_l686_action_invoke(&mut instance); + c675_l687_action_invoke(&mut instance); + c676_l688_action_invoke(&mut instance); + c677_l689_action_invoke(&mut instance); + c678_l690_action_invoke(&mut instance); + c679_l691_action_invoke(&mut instance); + c680_l692_action_invoke(&mut instance); + c681_l693_action_invoke(&mut instance); + c682_l694_action_invoke(&mut instance); + c683_l695_action_invoke(&mut instance); + c684_l696_action_invoke(&mut instance); + c685_l697_action_invoke(&mut instance); + c686_l698_action_invoke(&mut instance); + c687_l699_action_invoke(&mut instance); + c688_l700_action_invoke(&mut instance); + c689_l701_action_invoke(&mut instance); + c690_l702_action_invoke(&mut instance); + c691_l703_action_invoke(&mut instance); + c692_l704_action_invoke(&mut instance); + c693_l705_action_invoke(&mut instance); + c694_l706_action_invoke(&mut instance); + c695_l707_action_invoke(&mut instance); + c696_l708_action_invoke(&mut instance); + c697_l709_action_invoke(&mut instance); + c698_l710_action_invoke(&mut instance); + c699_l711_action_invoke(&mut instance); + c700_l712_action_invoke(&mut instance); + c701_l713_action_invoke(&mut instance); + c702_l714_action_invoke(&mut instance); + c703_l715_action_invoke(&mut instance); + c704_l716_action_invoke(&mut instance); + c705_l717_action_invoke(&mut instance); + c706_l718_action_invoke(&mut instance); + c707_l719_action_invoke(&mut instance); + c708_l720_action_invoke(&mut instance); + c709_l721_action_invoke(&mut instance); + c710_l722_action_invoke(&mut instance); + c711_l723_action_invoke(&mut instance); + c712_l724_action_invoke(&mut instance); + c713_l725_action_invoke(&mut instance); + c714_l726_action_invoke(&mut instance); + c715_l727_action_invoke(&mut instance); + c716_l728_action_invoke(&mut instance); + c717_l729_action_invoke(&mut instance); + c718_l730_action_invoke(&mut instance); + c719_l731_action_invoke(&mut instance); + c720_l732_action_invoke(&mut instance); + c721_l733_action_invoke(&mut instance); + c722_l734_action_invoke(&mut instance); + c723_l735_action_invoke(&mut instance); + c724_l736_action_invoke(&mut instance); + c725_l737_action_invoke(&mut instance); + c726_l738_action_invoke(&mut instance); + c727_l739_action_invoke(&mut instance); + c728_l740_action_invoke(&mut instance); + c729_l741_action_invoke(&mut instance); + c730_l742_action_invoke(&mut instance); + c731_l743_action_invoke(&mut instance); + c732_l744_action_invoke(&mut instance); + c733_l745_action_invoke(&mut instance); + c734_l746_action_invoke(&mut instance); + c735_l747_action_invoke(&mut instance); + c736_l748_action_invoke(&mut instance); + c737_l749_action_invoke(&mut instance); + c738_l750_action_invoke(&mut instance); + c739_l751_action_invoke(&mut instance); + c740_l752_action_invoke(&mut instance); + c741_l753_action_invoke(&mut instance); + c742_l754_action_invoke(&mut instance); + c743_l755_action_invoke(&mut instance); + c744_l756_action_invoke(&mut instance); + c745_l757_action_invoke(&mut instance); + c746_l758_action_invoke(&mut instance); + c747_l759_action_invoke(&mut instance); + c748_l760_action_invoke(&mut instance); + c749_l761_action_invoke(&mut instance); + c750_l762_action_invoke(&mut instance); + c751_l763_action_invoke(&mut instance); + c752_l764_action_invoke(&mut instance); + c753_l765_action_invoke(&mut instance); + c754_l766_action_invoke(&mut instance); + c755_l767_action_invoke(&mut instance); + c756_l768_action_invoke(&mut instance); + c757_l769_action_invoke(&mut instance); + c758_l770_action_invoke(&mut instance); + c759_l771_action_invoke(&mut instance); + c760_l772_action_invoke(&mut instance); + c761_l773_action_invoke(&mut instance); + c762_l774_action_invoke(&mut instance); + c763_l775_action_invoke(&mut instance); + c764_l776_action_invoke(&mut instance); + c765_l777_action_invoke(&mut instance); + c766_l778_action_invoke(&mut instance); + c767_l779_action_invoke(&mut instance); + c768_l780_action_invoke(&mut instance); + c769_l781_action_invoke(&mut instance); + c770_l782_action_invoke(&mut instance); + c771_l783_action_invoke(&mut instance); + c772_l784_action_invoke(&mut instance); + c773_l785_action_invoke(&mut instance); + c774_l786_action_invoke(&mut instance); + c775_l787_action_invoke(&mut instance); + c776_l788_action_invoke(&mut instance); + c777_l789_action_invoke(&mut instance); + c778_l790_action_invoke(&mut instance); + c779_l791_action_invoke(&mut instance); + c780_l792_action_invoke(&mut instance); + c781_l793_action_invoke(&mut instance); + c782_l794_action_invoke(&mut instance); + c783_l795_action_invoke(&mut instance); + c784_l796_action_invoke(&mut instance); + c785_l797_action_invoke(&mut instance); + c786_l798_action_invoke(&mut instance); + c787_l799_action_invoke(&mut instance); + c788_l800_action_invoke(&mut instance); + c789_l801_action_invoke(&mut instance); + c790_l802_action_invoke(&mut instance); + c791_l803_action_invoke(&mut instance); + c792_l804_action_invoke(&mut instance); + c793_l805_action_invoke(&mut instance); + c794_l806_action_invoke(&mut instance); + c795_l807_action_invoke(&mut instance); + c796_l808_action_invoke(&mut instance); + c797_l809_action_invoke(&mut instance); + c798_l810_action_invoke(&mut instance); + c799_l811_action_invoke(&mut instance); + c800_l812_action_invoke(&mut instance); + c801_l813_action_invoke(&mut instance); + c802_l814_action_invoke(&mut instance); + c803_l815_action_invoke(&mut instance); + c804_l816_action_invoke(&mut instance); + c805_l817_action_invoke(&mut instance); + c806_l818_action_invoke(&mut instance); + c807_l819_action_invoke(&mut instance); + c808_l820_action_invoke(&mut instance); + c809_l821_action_invoke(&mut instance); + c810_l822_action_invoke(&mut instance); + c811_l823_action_invoke(&mut instance); + c812_l824_action_invoke(&mut instance); + c813_l825_action_invoke(&mut instance); + c814_l826_action_invoke(&mut instance); + c815_l827_action_invoke(&mut instance); + c816_l828_action_invoke(&mut instance); + c817_l829_action_invoke(&mut instance); + c818_l830_action_invoke(&mut instance); + c819_l831_action_invoke(&mut instance); + c820_l832_action_invoke(&mut instance); + c821_l833_action_invoke(&mut instance); + c822_l834_action_invoke(&mut instance); + c823_l835_action_invoke(&mut instance); + c824_l836_action_invoke(&mut instance); + c825_l837_action_invoke(&mut instance); + c826_l838_action_invoke(&mut instance); + c827_l839_action_invoke(&mut instance); + c828_l840_action_invoke(&mut instance); + c829_l841_action_invoke(&mut instance); + c830_l842_action_invoke(&mut instance); + c831_l843_action_invoke(&mut instance); + c832_l844_action_invoke(&mut instance); + c833_l845_action_invoke(&mut instance); + c834_l846_action_invoke(&mut instance); + c835_l847_action_invoke(&mut instance); + c836_l848_action_invoke(&mut instance); + c837_l849_action_invoke(&mut instance); + c838_l850_action_invoke(&mut instance); + c839_l851_action_invoke(&mut instance); + c840_l852_action_invoke(&mut instance); + c841_l853_action_invoke(&mut instance); + c842_l854_action_invoke(&mut instance); + c843_l855_action_invoke(&mut instance); + c844_l856_action_invoke(&mut instance); + c845_l857_action_invoke(&mut instance); + c846_l858_action_invoke(&mut instance); + c847_l859_action_invoke(&mut instance); + c848_l860_action_invoke(&mut instance); + c849_l861_action_invoke(&mut instance); + c850_l862_action_invoke(&mut instance); + c851_l863_action_invoke(&mut instance); + c852_l864_action_invoke(&mut instance); + c853_l865_action_invoke(&mut instance); + c854_l866_action_invoke(&mut instance); + c855_l867_action_invoke(&mut instance); + c856_l868_action_invoke(&mut instance); + c857_l869_action_invoke(&mut instance); + c858_l870_action_invoke(&mut instance); + c859_l871_action_invoke(&mut instance); + c860_l872_action_invoke(&mut instance); + c861_l873_action_invoke(&mut instance); + c862_l874_action_invoke(&mut instance); + c863_l875_action_invoke(&mut instance); + c864_l876_action_invoke(&mut instance); + c865_l877_action_invoke(&mut instance); + c866_l878_action_invoke(&mut instance); + c867_l879_action_invoke(&mut instance); + c868_l880_action_invoke(&mut instance); + c869_l881_action_invoke(&mut instance); + c870_l882_action_invoke(&mut instance); + c871_l883_action_invoke(&mut instance); + c872_l884_action_invoke(&mut instance); + c873_l885_action_invoke(&mut instance); + c874_l886_action_invoke(&mut instance); + c875_l887_action_invoke(&mut instance); + c876_l888_action_invoke(&mut instance); + c877_l889_action_invoke(&mut instance); + c878_l890_action_invoke(&mut instance); + c879_l891_action_invoke(&mut instance); + c880_l892_action_invoke(&mut instance); + c881_l893_action_invoke(&mut instance); + c882_l894_action_invoke(&mut instance); + c883_l895_action_invoke(&mut instance); + c884_l896_action_invoke(&mut instance); + c885_l897_action_invoke(&mut instance); + c886_l898_action_invoke(&mut instance); + c887_l899_action_invoke(&mut instance); + c888_l900_action_invoke(&mut instance); + c889_l901_action_invoke(&mut instance); + c890_l902_action_invoke(&mut instance); + c891_l903_action_invoke(&mut instance); + c892_l904_action_invoke(&mut instance); + c893_l905_action_invoke(&mut instance); + c894_l906_action_invoke(&mut instance); + c895_l907_action_invoke(&mut instance); + c896_l908_action_invoke(&mut instance); + c897_l909_action_invoke(&mut instance); + c898_l910_action_invoke(&mut instance); + c899_l911_action_invoke(&mut instance); + c900_l912_action_invoke(&mut instance); + c901_l913_action_invoke(&mut instance); + c902_l914_action_invoke(&mut instance); + c903_l915_action_invoke(&mut instance); + c904_l916_action_invoke(&mut instance); + c905_l917_action_invoke(&mut instance); + c906_l918_action_invoke(&mut instance); + c907_l919_action_invoke(&mut instance); + c908_l920_action_invoke(&mut instance); + c909_l921_action_invoke(&mut instance); + c910_l922_action_invoke(&mut instance); + c911_l923_action_invoke(&mut instance); + c912_l924_action_invoke(&mut instance); + c913_l925_action_invoke(&mut instance); + c914_l926_action_invoke(&mut instance); + c915_l927_action_invoke(&mut instance); + c916_l928_action_invoke(&mut instance); + c917_l929_action_invoke(&mut instance); + c918_l930_action_invoke(&mut instance); + c919_l931_action_invoke(&mut instance); + c920_l932_action_invoke(&mut instance); + c921_l933_action_invoke(&mut instance); + c922_l934_action_invoke(&mut instance); + c923_l935_action_invoke(&mut instance); + c924_l936_action_invoke(&mut instance); + c925_l937_action_invoke(&mut instance); + c926_l938_action_invoke(&mut instance); + c927_l939_action_invoke(&mut instance); + c928_l940_action_invoke(&mut instance); + c929_l941_action_invoke(&mut instance); + c930_l942_action_invoke(&mut instance); + c931_l943_action_invoke(&mut instance); + c932_l944_action_invoke(&mut instance); + c933_l945_action_invoke(&mut instance); + c934_l946_action_invoke(&mut instance); + c935_l947_action_invoke(&mut instance); + c936_l948_action_invoke(&mut instance); + c937_l949_action_invoke(&mut instance); + c938_l950_action_invoke(&mut instance); + c939_l951_action_invoke(&mut instance); + c940_l952_action_invoke(&mut instance); + c941_l953_action_invoke(&mut instance); + c942_l954_action_invoke(&mut instance); + c943_l955_action_invoke(&mut instance); + c944_l956_action_invoke(&mut instance); + c945_l957_action_invoke(&mut instance); + c946_l958_action_invoke(&mut instance); + c947_l959_action_invoke(&mut instance); + c948_l960_action_invoke(&mut instance); + c949_l961_action_invoke(&mut instance); + c950_l962_action_invoke(&mut instance); + c951_l963_action_invoke(&mut instance); + c952_l964_action_invoke(&mut instance); + c953_l965_action_invoke(&mut instance); + c954_l966_action_invoke(&mut instance); + c955_l967_action_invoke(&mut instance); + c956_l968_action_invoke(&mut instance); + c957_l969_action_invoke(&mut instance); + c958_l970_action_invoke(&mut instance); + c959_l971_action_invoke(&mut instance); + c960_l972_action_invoke(&mut instance); + c961_l973_action_invoke(&mut instance); + c962_l974_action_invoke(&mut instance); + c963_l975_action_invoke(&mut instance); + c964_l976_action_invoke(&mut instance); + c965_l977_action_invoke(&mut instance); + c966_l978_action_invoke(&mut instance); + c967_l979_action_invoke(&mut instance); + c968_l980_action_invoke(&mut instance); + c969_l981_action_invoke(&mut instance); + c970_l982_action_invoke(&mut instance); + c971_l983_action_invoke(&mut instance); + c972_l984_action_invoke(&mut instance); + c973_l985_action_invoke(&mut instance); + c974_l986_action_invoke(&mut instance); + c975_l987_action_invoke(&mut instance); + c976_l988_action_invoke(&mut instance); + c977_l989_action_invoke(&mut instance); + c978_l990_action_invoke(&mut instance); + c979_l991_action_invoke(&mut instance); + c980_l992_action_invoke(&mut instance); + c981_l993_action_invoke(&mut instance); + c982_l994_action_invoke(&mut instance); + c983_l995_action_invoke(&mut instance); + c984_l996_action_invoke(&mut instance); + c985_l997_action_invoke(&mut instance); + c986_l998_action_invoke(&mut instance); + c987_l999_action_invoke(&mut instance); + c988_l1000_action_invoke(&mut instance); + c989_l1001_action_invoke(&mut instance); + c990_l1002_action_invoke(&mut instance); + c991_l1003_action_invoke(&mut instance); + c992_l1004_action_invoke(&mut instance); + c993_l1005_action_invoke(&mut instance); + c994_l1006_action_invoke(&mut instance); + c995_l1007_action_invoke(&mut instance); + c996_l1008_action_invoke(&mut instance); + c997_l1009_action_invoke(&mut instance); + c998_l1010_action_invoke(&mut instance); + c999_l1011_action_invoke(&mut instance); + c1000_l1012_action_invoke(&mut instance); + c1001_l1013_action_invoke(&mut instance); + c1002_l1014_action_invoke(&mut instance); + c1003_l1015_action_invoke(&mut instance); + c1004_l1016_action_invoke(&mut instance); + c1005_l1017_action_invoke(&mut instance); + c1006_l1018_action_invoke(&mut instance); + c1007_l1019_action_invoke(&mut instance); + c1008_l1020_action_invoke(&mut instance); + c1009_l1021_action_invoke(&mut instance); + c1010_l1022_action_invoke(&mut instance); + c1011_l1023_action_invoke(&mut instance); + c1012_l1024_action_invoke(&mut instance); + c1013_l1025_action_invoke(&mut instance); + c1014_l1026_action_invoke(&mut instance); + c1015_l1027_action_invoke(&mut instance); + c1016_l1028_action_invoke(&mut instance); + c1017_l1029_action_invoke(&mut instance); + c1018_l1030_action_invoke(&mut instance); + c1019_l1031_action_invoke(&mut instance); + c1020_l1032_action_invoke(&mut instance); + c1021_l1033_action_invoke(&mut instance); + c1022_l1034_action_invoke(&mut instance); + c1023_l1035_action_invoke(&mut instance); + c1024_l1036_action_invoke(&mut instance); + c1025_l1037_action_invoke(&mut instance); + c1026_l1038_action_invoke(&mut instance); + c1027_l1039_action_invoke(&mut instance); + c1028_l1040_action_invoke(&mut instance); + c1029_l1041_action_invoke(&mut instance); + c1030_l1042_action_invoke(&mut instance); + c1031_l1043_action_invoke(&mut instance); + c1032_l1044_action_invoke(&mut instance); + c1033_l1045_action_invoke(&mut instance); + c1034_l1046_action_invoke(&mut instance); + c1035_l1047_action_invoke(&mut instance); + c1036_l1048_action_invoke(&mut instance); + c1037_l1049_action_invoke(&mut instance); + c1038_l1050_action_invoke(&mut instance); + c1039_l1051_action_invoke(&mut instance); + c1040_l1052_action_invoke(&mut instance); + c1041_l1053_action_invoke(&mut instance); + c1042_l1054_action_invoke(&mut instance); + c1043_l1055_action_invoke(&mut instance); + c1044_l1056_action_invoke(&mut instance); + c1045_l1057_action_invoke(&mut instance); + c1046_l1058_action_invoke(&mut instance); + c1047_l1059_action_invoke(&mut instance); + c1048_l1060_action_invoke(&mut instance); + c1049_l1061_action_invoke(&mut instance); + c1050_l1062_action_invoke(&mut instance); + c1051_l1063_action_invoke(&mut instance); + c1052_l1064_action_invoke(&mut instance); + c1053_l1065_action_invoke(&mut instance); + c1054_l1066_action_invoke(&mut instance); + c1055_l1067_action_invoke(&mut instance); + c1056_l1068_action_invoke(&mut instance); + c1057_l1069_action_invoke(&mut instance); + c1058_l1070_action_invoke(&mut instance); + c1059_l1071_action_invoke(&mut instance); + c1060_l1072_action_invoke(&mut instance); + c1061_l1073_action_invoke(&mut instance); + c1062_l1074_action_invoke(&mut instance); + c1063_l1075_action_invoke(&mut instance); + c1064_l1076_action_invoke(&mut instance); + c1065_l1077_action_invoke(&mut instance); + c1066_l1078_action_invoke(&mut instance); + c1067_l1079_action_invoke(&mut instance); + c1068_l1080_action_invoke(&mut instance); + c1069_l1081_action_invoke(&mut instance); + c1070_l1082_action_invoke(&mut instance); + c1071_l1083_action_invoke(&mut instance); + c1072_l1084_action_invoke(&mut instance); + c1073_l1085_action_invoke(&mut instance); + c1074_l1086_action_invoke(&mut instance); + c1075_l1087_action_invoke(&mut instance); + c1076_l1088_action_invoke(&mut instance); + c1077_l1089_action_invoke(&mut instance); + c1078_l1090_action_invoke(&mut instance); + c1079_l1091_action_invoke(&mut instance); + c1080_l1092_action_invoke(&mut instance); + c1081_l1093_action_invoke(&mut instance); + c1082_l1094_action_invoke(&mut instance); + c1083_l1095_action_invoke(&mut instance); + c1084_l1096_action_invoke(&mut instance); + c1085_l1097_action_invoke(&mut instance); + c1086_l1098_action_invoke(&mut instance); + c1087_l1099_action_invoke(&mut instance); + c1088_l1100_action_invoke(&mut instance); + c1089_l1101_action_invoke(&mut instance); + c1090_l1102_action_invoke(&mut instance); + c1091_l1103_action_invoke(&mut instance); + c1092_l1104_action_invoke(&mut instance); + c1093_l1105_action_invoke(&mut instance); + c1094_l1106_action_invoke(&mut instance); + c1095_l1107_action_invoke(&mut instance); + c1096_l1108_action_invoke(&mut instance); + c1097_l1109_action_invoke(&mut instance); + c1098_l1110_action_invoke(&mut instance); + c1099_l1111_action_invoke(&mut instance); + c1100_l1112_action_invoke(&mut instance); + c1101_l1113_action_invoke(&mut instance); + c1102_l1114_action_invoke(&mut instance); + c1103_l1115_action_invoke(&mut instance); + c1104_l1116_action_invoke(&mut instance); + c1105_l1117_action_invoke(&mut instance); + c1106_l1118_action_invoke(&mut instance); + c1107_l1119_action_invoke(&mut instance); + c1108_l1120_action_invoke(&mut instance); + c1109_l1121_action_invoke(&mut instance); + c1110_l1122_action_invoke(&mut instance); + c1111_l1123_action_invoke(&mut instance); + c1112_l1124_action_invoke(&mut instance); + c1113_l1125_action_invoke(&mut instance); + c1114_l1126_action_invoke(&mut instance); + c1115_l1127_action_invoke(&mut instance); + c1116_l1128_action_invoke(&mut instance); + c1117_l1129_action_invoke(&mut instance); + c1118_l1130_action_invoke(&mut instance); + c1119_l1131_action_invoke(&mut instance); + c1120_l1132_action_invoke(&mut instance); + c1121_l1133_action_invoke(&mut instance); + c1122_l1134_action_invoke(&mut instance); + c1123_l1135_action_invoke(&mut instance); + c1124_l1136_action_invoke(&mut instance); + c1125_l1137_action_invoke(&mut instance); + c1126_l1138_action_invoke(&mut instance); + c1127_l1139_action_invoke(&mut instance); + c1128_l1140_action_invoke(&mut instance); + c1129_l1141_action_invoke(&mut instance); + c1130_l1142_action_invoke(&mut instance); + c1131_l1143_action_invoke(&mut instance); + c1132_l1144_action_invoke(&mut instance); + c1133_l1145_action_invoke(&mut instance); + c1134_l1146_action_invoke(&mut instance); + c1135_l1147_action_invoke(&mut instance); + c1136_l1148_action_invoke(&mut instance); + c1137_l1149_action_invoke(&mut instance); + c1138_l1150_action_invoke(&mut instance); + c1139_l1151_action_invoke(&mut instance); + c1140_l1152_action_invoke(&mut instance); + c1141_l1153_action_invoke(&mut instance); + c1142_l1154_action_invoke(&mut instance); + c1143_l1155_action_invoke(&mut instance); + c1144_l1156_action_invoke(&mut instance); + c1145_l1157_action_invoke(&mut instance); + c1146_l1158_action_invoke(&mut instance); + c1147_l1159_action_invoke(&mut instance); + c1148_l1160_action_invoke(&mut instance); + c1149_l1161_action_invoke(&mut instance); + c1150_l1162_action_invoke(&mut instance); + c1151_l1163_action_invoke(&mut instance); + c1152_l1164_action_invoke(&mut instance); + c1153_l1165_action_invoke(&mut instance); + c1154_l1166_action_invoke(&mut instance); + c1155_l1167_action_invoke(&mut instance); + c1156_l1168_action_invoke(&mut instance); + c1157_l1169_action_invoke(&mut instance); + c1158_l1170_action_invoke(&mut instance); + c1159_l1171_action_invoke(&mut instance); + c1160_l1172_action_invoke(&mut instance); + c1161_l1173_action_invoke(&mut instance); + c1162_l1174_action_invoke(&mut instance); + c1163_l1175_action_invoke(&mut instance); + c1164_l1176_action_invoke(&mut instance); + c1165_l1177_action_invoke(&mut instance); + c1166_l1178_action_invoke(&mut instance); + c1167_l1179_action_invoke(&mut instance); + c1168_l1180_action_invoke(&mut instance); + c1169_l1181_action_invoke(&mut instance); + c1170_l1182_action_invoke(&mut instance); + c1171_l1183_action_invoke(&mut instance); + c1172_l1184_action_invoke(&mut instance); + c1173_l1185_action_invoke(&mut instance); + c1174_l1186_action_invoke(&mut instance); + c1175_l1187_action_invoke(&mut instance); + c1176_l1188_action_invoke(&mut instance); + c1177_l1189_action_invoke(&mut instance); + c1178_l1190_action_invoke(&mut instance); + c1179_l1191_action_invoke(&mut instance); + c1180_l1192_action_invoke(&mut instance); + c1181_l1193_action_invoke(&mut instance); + c1182_l1194_action_invoke(&mut instance); + c1183_l1195_action_invoke(&mut instance); + c1184_l1196_action_invoke(&mut instance); + c1185_l1197_action_invoke(&mut instance); + c1186_l1198_action_invoke(&mut instance); + c1187_l1199_action_invoke(&mut instance); + c1188_l1200_action_invoke(&mut instance); + c1189_l1201_action_invoke(&mut instance); + c1190_l1202_action_invoke(&mut instance); + c1191_l1203_action_invoke(&mut instance); + c1192_l1204_action_invoke(&mut instance); + c1193_l1205_action_invoke(&mut instance); + c1194_l1206_action_invoke(&mut instance); + c1195_l1207_action_invoke(&mut instance); + c1196_l1208_action_invoke(&mut instance); + c1197_l1209_action_invoke(&mut instance); + c1198_l1210_action_invoke(&mut instance); + c1199_l1211_action_invoke(&mut instance); + c1200_l1212_action_invoke(&mut instance); + c1201_l1213_action_invoke(&mut instance); + c1202_l1214_action_invoke(&mut instance); + c1203_l1215_action_invoke(&mut instance); + c1204_l1216_action_invoke(&mut instance); + c1205_l1217_action_invoke(&mut instance); + c1206_l1218_action_invoke(&mut instance); + c1207_l1219_action_invoke(&mut instance); + c1208_l1220_action_invoke(&mut instance); + c1209_l1221_action_invoke(&mut instance); + c1210_l1222_action_invoke(&mut instance); + c1211_l1223_action_invoke(&mut instance); + c1212_l1224_action_invoke(&mut instance); + c1213_l1225_action_invoke(&mut instance); + c1214_l1226_action_invoke(&mut instance); + c1215_l1227_action_invoke(&mut instance); + c1216_l1228_action_invoke(&mut instance); + c1217_l1229_action_invoke(&mut instance); + c1218_l1230_action_invoke(&mut instance); + c1219_l1231_action_invoke(&mut instance); + c1220_l1232_action_invoke(&mut instance); + c1221_l1233_action_invoke(&mut instance); + c1222_l1234_action_invoke(&mut instance); + c1223_l1235_action_invoke(&mut instance); + c1224_l1236_action_invoke(&mut instance); + c1225_l1237_action_invoke(&mut instance); + c1226_l1238_action_invoke(&mut instance); + c1227_l1239_action_invoke(&mut instance); + c1228_l1240_action_invoke(&mut instance); + c1229_l1241_action_invoke(&mut instance); + c1230_l1242_action_invoke(&mut instance); + c1231_l1243_action_invoke(&mut instance); + c1232_l1244_action_invoke(&mut instance); + c1233_l1245_action_invoke(&mut instance); + c1234_l1246_action_invoke(&mut instance); + c1235_l1247_action_invoke(&mut instance); + c1236_l1248_action_invoke(&mut instance); + c1237_l1249_action_invoke(&mut instance); + c1238_l1250_action_invoke(&mut instance); + c1239_l1251_action_invoke(&mut instance); + c1240_l1252_action_invoke(&mut instance); + c1241_l1253_action_invoke(&mut instance); + c1242_l1254_action_invoke(&mut instance); + c1243_l1255_action_invoke(&mut instance); + c1244_l1256_action_invoke(&mut instance); + c1245_l1257_action_invoke(&mut instance); + c1246_l1258_action_invoke(&mut instance); + c1247_l1259_action_invoke(&mut instance); + c1248_l1260_action_invoke(&mut instance); + c1249_l1261_action_invoke(&mut instance); + c1250_l1262_action_invoke(&mut instance); + c1251_l1263_action_invoke(&mut instance); + c1252_l1264_action_invoke(&mut instance); + c1253_l1265_action_invoke(&mut instance); + c1254_l1266_action_invoke(&mut instance); + c1255_l1267_action_invoke(&mut instance); + c1256_l1268_action_invoke(&mut instance); + c1257_l1269_action_invoke(&mut instance); + c1258_l1270_action_invoke(&mut instance); + c1259_l1271_action_invoke(&mut instance); + c1260_l1272_action_invoke(&mut instance); + c1261_l1273_action_invoke(&mut instance); + c1262_l1274_action_invoke(&mut instance); + c1263_l1275_action_invoke(&mut instance); + c1264_l1276_action_invoke(&mut instance); + c1265_l1277_action_invoke(&mut instance); + c1266_l1278_action_invoke(&mut instance); + c1267_l1279_action_invoke(&mut instance); + c1268_l1280_action_invoke(&mut instance); + c1269_l1281_action_invoke(&mut instance); + c1270_l1282_action_invoke(&mut instance); + c1271_l1283_action_invoke(&mut instance); + c1272_l1284_action_invoke(&mut instance); + c1273_l1285_action_invoke(&mut instance); + c1274_l1286_action_invoke(&mut instance); + c1275_l1287_action_invoke(&mut instance); + c1276_l1288_action_invoke(&mut instance); + c1277_l1289_action_invoke(&mut instance); + c1278_l1290_action_invoke(&mut instance); + c1279_l1291_action_invoke(&mut instance); + c1280_l1292_action_invoke(&mut instance); + c1281_l1293_action_invoke(&mut instance); + c1282_l1294_action_invoke(&mut instance); + c1283_l1295_action_invoke(&mut instance); + c1284_l1296_action_invoke(&mut instance); + c1285_l1297_action_invoke(&mut instance); + c1286_l1298_action_invoke(&mut instance); + c1287_l1299_action_invoke(&mut instance); + c1288_l1300_action_invoke(&mut instance); + c1289_l1301_action_invoke(&mut instance); + c1290_l1302_action_invoke(&mut instance); + c1291_l1303_action_invoke(&mut instance); + c1292_l1304_action_invoke(&mut instance); + c1293_l1305_action_invoke(&mut instance); + c1294_l1306_action_invoke(&mut instance); + c1295_l1307_action_invoke(&mut instance); + c1296_l1308_action_invoke(&mut instance); + c1297_l1309_action_invoke(&mut instance); + c1298_l1310_action_invoke(&mut instance); + c1299_l1311_action_invoke(&mut instance); + c1300_l1312_action_invoke(&mut instance); + c1301_l1313_action_invoke(&mut instance); + c1302_l1314_action_invoke(&mut instance); + c1303_l1315_action_invoke(&mut instance); + c1304_l1316_action_invoke(&mut instance); + c1305_l1317_action_invoke(&mut instance); + c1306_l1318_action_invoke(&mut instance); + c1307_l1319_action_invoke(&mut instance); + c1308_l1320_action_invoke(&mut instance); + c1309_l1321_action_invoke(&mut instance); + c1310_l1322_action_invoke(&mut instance); + c1311_l1323_action_invoke(&mut instance); + c1312_l1324_action_invoke(&mut instance); + c1313_l1325_action_invoke(&mut instance); + c1314_l1326_action_invoke(&mut instance); + c1315_l1327_action_invoke(&mut instance); + c1316_l1328_action_invoke(&mut instance); + c1317_l1329_action_invoke(&mut instance); + c1318_l1330_action_invoke(&mut instance); + c1319_l1331_action_invoke(&mut instance); + c1320_l1332_action_invoke(&mut instance); + c1321_l1333_action_invoke(&mut instance); + c1322_l1334_action_invoke(&mut instance); + c1323_l1335_action_invoke(&mut instance); + c1324_l1336_action_invoke(&mut instance); + c1325_l1337_action_invoke(&mut instance); + c1326_l1338_action_invoke(&mut instance); + c1327_l1339_action_invoke(&mut instance); + c1328_l1340_action_invoke(&mut instance); + c1329_l1341_action_invoke(&mut instance); + c1330_l1342_action_invoke(&mut instance); + c1331_l1343_action_invoke(&mut instance); + c1332_l1344_action_invoke(&mut instance); + c1333_l1345_action_invoke(&mut instance); + c1334_l1346_action_invoke(&mut instance); + c1335_l1347_action_invoke(&mut instance); + c1336_l1348_action_invoke(&mut instance); + c1337_l1349_action_invoke(&mut instance); + c1338_l1350_action_invoke(&mut instance); + c1339_l1351_action_invoke(&mut instance); + c1340_l1352_action_invoke(&mut instance); + c1341_l1353_action_invoke(&mut instance); + c1342_l1354_action_invoke(&mut instance); + c1343_l1355_action_invoke(&mut instance); + c1344_l1356_action_invoke(&mut instance); + c1345_l1357_action_invoke(&mut instance); + c1346_l1358_action_invoke(&mut instance); + c1347_l1359_action_invoke(&mut instance); + c1348_l1360_action_invoke(&mut instance); + c1349_l1361_action_invoke(&mut instance); + c1350_l1362_action_invoke(&mut instance); + c1351_l1363_action_invoke(&mut instance); + c1352_l1364_action_invoke(&mut instance); + c1353_l1365_action_invoke(&mut instance); + c1354_l1366_action_invoke(&mut instance); + c1355_l1367_action_invoke(&mut instance); + c1356_l1368_action_invoke(&mut instance); + c1357_l1369_action_invoke(&mut instance); + c1358_l1370_action_invoke(&mut instance); + c1359_l1371_action_invoke(&mut instance); + c1360_l1372_action_invoke(&mut instance); + c1361_l1373_action_invoke(&mut instance); + c1362_l1374_action_invoke(&mut instance); + c1363_l1375_action_invoke(&mut instance); + c1364_l1376_action_invoke(&mut instance); + c1365_l1377_action_invoke(&mut instance); + c1366_l1378_action_invoke(&mut instance); + c1367_l1379_action_invoke(&mut instance); + c1368_l1380_action_invoke(&mut instance); + c1369_l1381_action_invoke(&mut instance); + c1370_l1382_action_invoke(&mut instance); + c1371_l1383_action_invoke(&mut instance); + c1372_l1384_action_invoke(&mut instance); + c1373_l1385_action_invoke(&mut instance); + c1374_l1386_action_invoke(&mut instance); + c1375_l1387_action_invoke(&mut instance); + c1376_l1388_action_invoke(&mut instance); + c1377_l1389_action_invoke(&mut instance); + c1378_l1390_action_invoke(&mut instance); + c1379_l1391_action_invoke(&mut instance); + c1380_l1392_action_invoke(&mut instance); + c1381_l1393_action_invoke(&mut instance); + c1382_l1394_action_invoke(&mut instance); + c1383_l1395_action_invoke(&mut instance); + c1384_l1396_action_invoke(&mut instance); + c1385_l1397_action_invoke(&mut instance); + c1386_l1398_action_invoke(&mut instance); + c1387_l1399_action_invoke(&mut instance); + c1388_l1400_action_invoke(&mut instance); + c1389_l1401_action_invoke(&mut instance); + c1390_l1402_action_invoke(&mut instance); + c1391_l1403_action_invoke(&mut instance); + c1392_l1404_action_invoke(&mut instance); + c1393_l1405_action_invoke(&mut instance); + c1394_l1406_action_invoke(&mut instance); + c1395_l1407_action_invoke(&mut instance); + c1396_l1408_action_invoke(&mut instance); + c1397_l1409_action_invoke(&mut instance); + c1398_l1410_action_invoke(&mut instance); + c1399_l1411_action_invoke(&mut instance); + c1400_l1412_action_invoke(&mut instance); + c1401_l1413_action_invoke(&mut instance); + c1402_l1414_action_invoke(&mut instance); + c1403_l1415_action_invoke(&mut instance); + c1404_l1416_action_invoke(&mut instance); + c1405_l1417_action_invoke(&mut instance); + c1406_l1418_action_invoke(&mut instance); + c1407_l1419_action_invoke(&mut instance); + c1408_l1420_action_invoke(&mut instance); + c1409_l1421_action_invoke(&mut instance); + c1410_l1422_action_invoke(&mut instance); + c1411_l1423_action_invoke(&mut instance); + c1412_l1424_action_invoke(&mut instance); + c1413_l1425_action_invoke(&mut instance); + c1414_l1426_action_invoke(&mut instance); + c1415_l1427_action_invoke(&mut instance); + c1416_l1428_action_invoke(&mut instance); + c1417_l1429_action_invoke(&mut instance); + c1418_l1430_action_invoke(&mut instance); + c1419_l1431_action_invoke(&mut instance); + c1420_l1432_action_invoke(&mut instance); + c1421_l1433_action_invoke(&mut instance); + c1422_l1434_action_invoke(&mut instance); + c1423_l1435_action_invoke(&mut instance); + c1424_l1436_action_invoke(&mut instance); + c1425_l1437_action_invoke(&mut instance); + c1426_l1438_action_invoke(&mut instance); + c1427_l1439_action_invoke(&mut instance); + c1428_l1440_action_invoke(&mut instance); + c1429_l1441_action_invoke(&mut instance); + c1430_l1442_action_invoke(&mut instance); + c1431_l1443_action_invoke(&mut instance); + c1432_l1444_action_invoke(&mut instance); + c1433_l1445_action_invoke(&mut instance); + c1434_l1446_action_invoke(&mut instance); + c1435_l1447_action_invoke(&mut instance); + c1436_l1448_action_invoke(&mut instance); + c1437_l1449_action_invoke(&mut instance); + c1438_l1450_action_invoke(&mut instance); + c1439_l1451_action_invoke(&mut instance); + c1440_l1452_action_invoke(&mut instance); + c1441_l1453_action_invoke(&mut instance); + c1442_l1454_action_invoke(&mut instance); + c1443_l1455_action_invoke(&mut instance); + c1444_l1456_action_invoke(&mut instance); + c1445_l1457_action_invoke(&mut instance); + c1446_l1458_action_invoke(&mut instance); + c1447_l1459_action_invoke(&mut instance); + c1448_l1460_action_invoke(&mut instance); + c1449_l1461_action_invoke(&mut instance); + c1450_l1462_action_invoke(&mut instance); + c1451_l1463_action_invoke(&mut instance); + c1452_l1464_action_invoke(&mut instance); + c1453_l1465_action_invoke(&mut instance); + c1454_l1466_action_invoke(&mut instance); + c1455_l1467_action_invoke(&mut instance); + c1456_l1468_action_invoke(&mut instance); + c1457_l1469_action_invoke(&mut instance); + c1458_l1470_action_invoke(&mut instance); + c1459_l1471_action_invoke(&mut instance); + c1460_l1472_action_invoke(&mut instance); + c1461_l1473_action_invoke(&mut instance); + c1462_l1474_action_invoke(&mut instance); + c1463_l1475_action_invoke(&mut instance); + c1464_l1476_action_invoke(&mut instance); + c1465_l1477_action_invoke(&mut instance); + c1466_l1478_action_invoke(&mut instance); + c1467_l1479_action_invoke(&mut instance); + c1468_l1480_action_invoke(&mut instance); + c1469_l1481_action_invoke(&mut instance); + c1470_l1482_action_invoke(&mut instance); + c1471_l1483_action_invoke(&mut instance); + c1472_l1484_action_invoke(&mut instance); + c1473_l1485_action_invoke(&mut instance); + c1474_l1486_action_invoke(&mut instance); + c1475_l1487_action_invoke(&mut instance); + c1476_l1488_action_invoke(&mut instance); + c1477_l1489_action_invoke(&mut instance); + c1478_l1490_action_invoke(&mut instance); + c1479_l1491_action_invoke(&mut instance); + c1480_l1492_action_invoke(&mut instance); + c1481_l1493_action_invoke(&mut instance); + c1482_l1494_action_invoke(&mut instance); + c1483_l1495_action_invoke(&mut instance); + c1484_l1496_action_invoke(&mut instance); + c1485_l1497_action_invoke(&mut instance); + c1486_l1498_action_invoke(&mut instance); + c1487_l1499_action_invoke(&mut instance); + c1488_l1500_action_invoke(&mut instance); + c1489_l1501_action_invoke(&mut instance); + c1490_l1502_action_invoke(&mut instance); + c1491_l1503_action_invoke(&mut instance); + c1492_l1504_action_invoke(&mut instance); + c1493_l1505_action_invoke(&mut instance); + c1494_l1506_action_invoke(&mut instance); + c1495_l1507_action_invoke(&mut instance); + c1496_l1508_action_invoke(&mut instance); + c1497_l1509_action_invoke(&mut instance); + c1498_l1510_action_invoke(&mut instance); + c1499_l1511_action_invoke(&mut instance); + c1500_l1512_action_invoke(&mut instance); + c1501_l1513_action_invoke(&mut instance); + c1502_l1514_action_invoke(&mut instance); + c1503_l1515_action_invoke(&mut instance); + c1504_l1516_action_invoke(&mut instance); + c1505_l1517_action_invoke(&mut instance); + c1506_l1518_action_invoke(&mut instance); + c1507_l1519_action_invoke(&mut instance); + c1508_l1520_action_invoke(&mut instance); + c1509_l1521_action_invoke(&mut instance); + c1510_l1522_action_invoke(&mut instance); + c1511_l1523_action_invoke(&mut instance); + c1512_l1524_action_invoke(&mut instance); + c1513_l1525_action_invoke(&mut instance); + c1514_l1526_action_invoke(&mut instance); + c1515_l1527_action_invoke(&mut instance); + c1516_l1528_action_invoke(&mut instance); + c1517_l1529_action_invoke(&mut instance); + c1518_l1530_action_invoke(&mut instance); + c1519_l1531_action_invoke(&mut instance); + c1520_l1532_action_invoke(&mut instance); + c1521_l1533_action_invoke(&mut instance); + c1522_l1534_action_invoke(&mut instance); + c1523_l1535_action_invoke(&mut instance); + c1524_l1536_action_invoke(&mut instance); + c1525_l1537_action_invoke(&mut instance); + c1526_l1538_action_invoke(&mut instance); + c1527_l1539_action_invoke(&mut instance); + c1528_l1540_action_invoke(&mut instance); + c1529_l1541_action_invoke(&mut instance); + c1530_l1542_action_invoke(&mut instance); + c1531_l1543_action_invoke(&mut instance); + c1532_l1544_action_invoke(&mut instance); + c1533_l1545_action_invoke(&mut instance); + c1534_l1546_action_invoke(&mut instance); + c1535_l1547_action_invoke(&mut instance); + c1536_l1548_action_invoke(&mut instance); + c1537_l1549_action_invoke(&mut instance); + c1538_l1550_action_invoke(&mut instance); + c1539_l1551_action_invoke(&mut instance); + c1540_l1552_action_invoke(&mut instance); + c1541_l1553_action_invoke(&mut instance); + c1542_l1554_action_invoke(&mut instance); + c1543_l1555_action_invoke(&mut instance); + c1544_l1556_action_invoke(&mut instance); + c1545_l1557_action_invoke(&mut instance); + c1546_l1558_action_invoke(&mut instance); + c1547_l1559_action_invoke(&mut instance); + c1548_l1560_action_invoke(&mut instance); + c1549_l1561_action_invoke(&mut instance); + c1550_l1562_action_invoke(&mut instance); + c1551_l1563_action_invoke(&mut instance); + c1552_l1564_action_invoke(&mut instance); + c1553_l1565_action_invoke(&mut instance); + c1554_l1566_action_invoke(&mut instance); + c1555_l1567_action_invoke(&mut instance); + c1556_l1568_action_invoke(&mut instance); + c1557_l1569_action_invoke(&mut instance); + c1558_l1570_action_invoke(&mut instance); + c1559_l1571_action_invoke(&mut instance); + c1560_l1572_action_invoke(&mut instance); + c1561_l1573_action_invoke(&mut instance); + c1562_l1574_action_invoke(&mut instance); + c1563_l1575_action_invoke(&mut instance); + c1564_l1576_action_invoke(&mut instance); + c1565_l1577_action_invoke(&mut instance); + c1566_l1578_action_invoke(&mut instance); + c1567_l1579_action_invoke(&mut instance); + c1568_l1580_action_invoke(&mut instance); + c1569_l1581_action_invoke(&mut instance); + c1570_l1582_action_invoke(&mut instance); + c1571_l1583_action_invoke(&mut instance); + c1572_l1584_action_invoke(&mut instance); + c1573_l1585_action_invoke(&mut instance); + c1574_l1586_action_invoke(&mut instance); + c1575_l1587_action_invoke(&mut instance); + c1576_l1588_action_invoke(&mut instance); + c1577_l1589_action_invoke(&mut instance); + c1578_l1590_action_invoke(&mut instance); + c1579_l1591_action_invoke(&mut instance); + c1580_l1592_action_invoke(&mut instance); + c1581_l1593_action_invoke(&mut instance); + c1582_l1594_action_invoke(&mut instance); + c1583_l1595_action_invoke(&mut instance); + c1584_l1596_action_invoke(&mut instance); + c1585_l1597_action_invoke(&mut instance); + c1586_l1598_action_invoke(&mut instance); + c1587_l1599_action_invoke(&mut instance); + c1588_l1600_action_invoke(&mut instance); + c1589_l1601_action_invoke(&mut instance); + c1590_l1602_action_invoke(&mut instance); + c1591_l1603_action_invoke(&mut instance); + c1592_l1604_action_invoke(&mut instance); + c1593_l1605_action_invoke(&mut instance); + c1594_l1606_action_invoke(&mut instance); + c1595_l1607_action_invoke(&mut instance); + c1596_l1608_action_invoke(&mut instance); + c1597_l1609_action_invoke(&mut instance); + c1598_l1610_action_invoke(&mut instance); + c1599_l1611_action_invoke(&mut instance); + c1600_l1612_action_invoke(&mut instance); + c1601_l1613_action_invoke(&mut instance); + c1602_l1614_action_invoke(&mut instance); + c1603_l1615_action_invoke(&mut instance); + c1604_l1616_action_invoke(&mut instance); + c1605_l1617_action_invoke(&mut instance); + c1606_l1618_action_invoke(&mut instance); + c1607_l1619_action_invoke(&mut instance); + c1608_l1620_action_invoke(&mut instance); + c1609_l1621_action_invoke(&mut instance); + c1610_l1622_action_invoke(&mut instance); + c1611_l1623_action_invoke(&mut instance); + c1612_l1624_action_invoke(&mut instance); + c1613_l1625_action_invoke(&mut instance); + c1614_l1626_action_invoke(&mut instance); + c1615_l1627_action_invoke(&mut instance); + c1616_l1628_action_invoke(&mut instance); + c1617_l1629_action_invoke(&mut instance); + c1618_l1630_action_invoke(&mut instance); + c1619_l1631_action_invoke(&mut instance); + c1620_l1632_action_invoke(&mut instance); + c1621_l1633_action_invoke(&mut instance); + c1622_l1634_action_invoke(&mut instance); + c1623_l1635_action_invoke(&mut instance); + c1624_l1636_action_invoke(&mut instance); + c1625_l1637_action_invoke(&mut instance); + c1626_l1638_action_invoke(&mut instance); + c1627_l1639_action_invoke(&mut instance); + c1628_l1640_action_invoke(&mut instance); + c1629_l1641_action_invoke(&mut instance); + c1630_l1642_action_invoke(&mut instance); + c1631_l1643_action_invoke(&mut instance); + c1632_l1644_action_invoke(&mut instance); + c1633_l1645_action_invoke(&mut instance); + c1634_l1646_action_invoke(&mut instance); + c1635_l1647_action_invoke(&mut instance); + c1636_l1648_action_invoke(&mut instance); + c1637_l1649_action_invoke(&mut instance); + c1638_l1650_action_invoke(&mut instance); + c1639_l1651_action_invoke(&mut instance); + c1640_l1652_action_invoke(&mut instance); + c1641_l1653_action_invoke(&mut instance); + c1642_l1654_action_invoke(&mut instance); + c1643_l1655_action_invoke(&mut instance); + c1644_l1656_action_invoke(&mut instance); + c1645_l1657_action_invoke(&mut instance); + c1646_l1658_action_invoke(&mut instance); + c1647_l1659_action_invoke(&mut instance); + c1648_l1660_action_invoke(&mut instance); + c1649_l1661_action_invoke(&mut instance); + c1650_l1662_action_invoke(&mut instance); + c1651_l1663_action_invoke(&mut instance); + c1652_l1664_action_invoke(&mut instance); + c1653_l1665_action_invoke(&mut instance); + c1654_l1666_action_invoke(&mut instance); + c1655_l1667_action_invoke(&mut instance); + c1656_l1668_action_invoke(&mut instance); + c1657_l1669_action_invoke(&mut instance); + c1658_l1670_action_invoke(&mut instance); + c1659_l1671_action_invoke(&mut instance); + c1660_l1672_action_invoke(&mut instance); + c1661_l1673_action_invoke(&mut instance); + c1662_l1674_action_invoke(&mut instance); + c1663_l1675_action_invoke(&mut instance); + c1664_l1676_action_invoke(&mut instance); + c1665_l1677_action_invoke(&mut instance); + c1666_l1678_action_invoke(&mut instance); + c1667_l1679_action_invoke(&mut instance); + c1668_l1680_action_invoke(&mut instance); + c1669_l1681_action_invoke(&mut instance); + c1670_l1682_action_invoke(&mut instance); + c1671_l1683_action_invoke(&mut instance); + c1672_l1684_action_invoke(&mut instance); + c1673_l1685_action_invoke(&mut instance); + c1674_l1686_action_invoke(&mut instance); + c1675_l1687_action_invoke(&mut instance); + c1676_l1688_action_invoke(&mut instance); + c1677_l1689_action_invoke(&mut instance); + c1678_l1690_action_invoke(&mut instance); + c1679_l1691_action_invoke(&mut instance); + c1680_l1692_action_invoke(&mut instance); + c1681_l1693_action_invoke(&mut instance); + c1682_l1694_action_invoke(&mut instance); + c1683_l1695_action_invoke(&mut instance); + c1684_l1696_action_invoke(&mut instance); + c1685_l1697_action_invoke(&mut instance); + c1686_l1698_action_invoke(&mut instance); + c1687_l1699_action_invoke(&mut instance); + c1688_l1700_action_invoke(&mut instance); + c1689_l1701_action_invoke(&mut instance); + c1690_l1702_action_invoke(&mut instance); + c1691_l1703_action_invoke(&mut instance); + c1692_l1704_action_invoke(&mut instance); + c1693_l1705_action_invoke(&mut instance); + c1694_l1706_action_invoke(&mut instance); + c1695_l1707_action_invoke(&mut instance); + c1696_l1708_action_invoke(&mut instance); + c1697_l1709_action_invoke(&mut instance); + c1698_l1710_action_invoke(&mut instance); + c1699_l1711_action_invoke(&mut instance); + c1700_l1712_action_invoke(&mut instance); + c1701_l1713_action_invoke(&mut instance); + c1702_l1714_action_invoke(&mut instance); + c1703_l1715_action_invoke(&mut instance); + c1704_l1716_action_invoke(&mut instance); + c1705_l1717_action_invoke(&mut instance); + c1706_l1718_action_invoke(&mut instance); + c1707_l1719_action_invoke(&mut instance); + c1708_l1720_action_invoke(&mut instance); + c1709_l1721_action_invoke(&mut instance); + c1710_l1722_action_invoke(&mut instance); + c1711_l1723_action_invoke(&mut instance); + c1712_l1724_action_invoke(&mut instance); + c1713_l1725_action_invoke(&mut instance); + c1714_l1726_action_invoke(&mut instance); + c1715_l1727_action_invoke(&mut instance); + c1716_l1728_action_invoke(&mut instance); + c1717_l1729_action_invoke(&mut instance); + c1718_l1730_action_invoke(&mut instance); + c1719_l1731_action_invoke(&mut instance); + c1720_l1732_action_invoke(&mut instance); + c1721_l1733_action_invoke(&mut instance); + c1722_l1734_action_invoke(&mut instance); + c1723_l1735_action_invoke(&mut instance); + c1724_l1736_action_invoke(&mut instance); + c1725_l1737_action_invoke(&mut instance); + c1726_l1738_action_invoke(&mut instance); + c1727_l1739_action_invoke(&mut instance); + c1728_l1740_action_invoke(&mut instance); + c1729_l1741_action_invoke(&mut instance); + c1730_l1742_action_invoke(&mut instance); + c1731_l1743_action_invoke(&mut instance); + c1732_l1744_action_invoke(&mut instance); + c1733_l1745_action_invoke(&mut instance); + c1734_l1746_action_invoke(&mut instance); + c1735_l1747_action_invoke(&mut instance); + c1736_l1748_action_invoke(&mut instance); + c1737_l1749_action_invoke(&mut instance); + c1738_l1750_action_invoke(&mut instance); + c1739_l1751_action_invoke(&mut instance); + c1740_l1752_action_invoke(&mut instance); + c1741_l1753_action_invoke(&mut instance); + c1742_l1754_action_invoke(&mut instance); + c1743_l1755_action_invoke(&mut instance); + c1744_l1756_action_invoke(&mut instance); + c1745_l1757_action_invoke(&mut instance); + c1746_l1758_action_invoke(&mut instance); + c1747_l1759_action_invoke(&mut instance); + c1748_l1760_action_invoke(&mut instance); + c1749_l1761_action_invoke(&mut instance); + c1750_l1762_action_invoke(&mut instance); + c1751_l1763_action_invoke(&mut instance); + c1752_l1764_action_invoke(&mut instance); + c1753_l1765_action_invoke(&mut instance); + c1754_l1766_action_invoke(&mut instance); + c1755_l1767_action_invoke(&mut instance); + c1756_l1768_action_invoke(&mut instance); + c1757_l1769_action_invoke(&mut instance); + c1758_l1770_action_invoke(&mut instance); + c1759_l1771_action_invoke(&mut instance); + c1760_l1772_action_invoke(&mut instance); + c1761_l1773_action_invoke(&mut instance); + c1762_l1774_action_invoke(&mut instance); + c1763_l1775_action_invoke(&mut instance); + c1764_l1776_action_invoke(&mut instance); + c1765_l1777_action_invoke(&mut instance); + c1766_l1778_action_invoke(&mut instance); + c1767_l1779_action_invoke(&mut instance); + c1768_l1780_action_invoke(&mut instance); + c1769_l1781_action_invoke(&mut instance); + c1770_l1782_action_invoke(&mut instance); + c1771_l1783_action_invoke(&mut instance); + c1772_l1784_action_invoke(&mut instance); + c1773_l1785_action_invoke(&mut instance); + c1774_l1786_action_invoke(&mut instance); + c1775_l1787_action_invoke(&mut instance); + c1776_l1788_action_invoke(&mut instance); + c1777_l1789_action_invoke(&mut instance); + c1778_l1790_action_invoke(&mut instance); + c1779_l1791_action_invoke(&mut instance); + c1780_l1792_action_invoke(&mut instance); + c1781_l1793_action_invoke(&mut instance); + c1782_l1794_action_invoke(&mut instance); + c1783_l1795_action_invoke(&mut instance); + c1784_l1796_action_invoke(&mut instance); + c1785_l1797_action_invoke(&mut instance); + c1786_l1798_action_invoke(&mut instance); + c1787_l1799_action_invoke(&mut instance); + c1788_l1800_action_invoke(&mut instance); + c1789_l1801_action_invoke(&mut instance); + c1790_l1802_action_invoke(&mut instance); + c1791_l1803_action_invoke(&mut instance); + c1792_l1804_action_invoke(&mut instance); + c1793_l1805_action_invoke(&mut instance); + c1794_l1806_action_invoke(&mut instance); + c1795_l1807_action_invoke(&mut instance); + c1796_l1808_action_invoke(&mut instance); + c1797_l1809_action_invoke(&mut instance); + c1798_l1810_action_invoke(&mut instance); + c1799_l1811_action_invoke(&mut instance); + c1800_l1812_action_invoke(&mut instance); + c1801_l1813_action_invoke(&mut instance); + c1802_l1814_action_invoke(&mut instance); + c1803_l1815_action_invoke(&mut instance); + c1804_l1816_action_invoke(&mut instance); + c1805_l1817_action_invoke(&mut instance); + c1806_l1818_action_invoke(&mut instance); + c1807_l1819_action_invoke(&mut instance); + c1808_l1820_action_invoke(&mut instance); + c1809_l1821_action_invoke(&mut instance); + c1810_l1822_action_invoke(&mut instance); + c1811_l1823_action_invoke(&mut instance); + c1812_l1824_action_invoke(&mut instance); + c1813_l1825_action_invoke(&mut instance); + c1814_l1826_action_invoke(&mut instance); + c1815_l1827_action_invoke(&mut instance); + c1816_l1828_action_invoke(&mut instance); + c1817_l1829_action_invoke(&mut instance); + c1818_l1830_action_invoke(&mut instance); + c1819_l1831_action_invoke(&mut instance); + c1820_l1832_action_invoke(&mut instance); + c1821_l1833_action_invoke(&mut instance); + c1822_l1834_action_invoke(&mut instance); + c1823_l1835_action_invoke(&mut instance); + c1824_l1836_action_invoke(&mut instance); + c1825_l1837_action_invoke(&mut instance); + c1826_l1838_action_invoke(&mut instance); + c1827_l1839_action_invoke(&mut instance); + c1828_l1840_action_invoke(&mut instance); + c1829_l1841_action_invoke(&mut instance); + c1830_l1842_action_invoke(&mut instance); + c1831_l1843_action_invoke(&mut instance); + c1832_l1844_action_invoke(&mut instance); + c1833_l1845_action_invoke(&mut instance); + c1834_l1846_action_invoke(&mut instance); + c1835_l1847_action_invoke(&mut instance); + c1836_l1848_action_invoke(&mut instance); + c1837_l1849_action_invoke(&mut instance); + c1838_l1850_action_invoke(&mut instance); + c1839_l1851_action_invoke(&mut instance); + c1840_l1852_action_invoke(&mut instance); + c1841_l1853_action_invoke(&mut instance); + c1842_l1854_action_invoke(&mut instance); + c1843_l1855_action_invoke(&mut instance); + c1844_l1856_action_invoke(&mut instance); + c1845_l1857_action_invoke(&mut instance); + c1846_l1858_action_invoke(&mut instance); + c1847_l1859_action_invoke(&mut instance); + c1848_l1860_action_invoke(&mut instance); + c1849_l1861_action_invoke(&mut instance); + c1850_l1862_action_invoke(&mut instance); + c1851_l1863_action_invoke(&mut instance); + c1852_l1864_action_invoke(&mut instance); + c1853_l1865_action_invoke(&mut instance); + c1854_l1866_action_invoke(&mut instance); + c1855_l1867_action_invoke(&mut instance); + c1856_l1868_action_invoke(&mut instance); + c1857_l1869_action_invoke(&mut instance); + c1858_l1870_action_invoke(&mut instance); + c1859_l1871_action_invoke(&mut instance); + c1860_l1872_action_invoke(&mut instance); + c1861_l1873_action_invoke(&mut instance); + c1862_l1874_action_invoke(&mut instance); + c1863_l1875_action_invoke(&mut instance); + c1864_l1876_action_invoke(&mut instance); + c1865_l1877_action_invoke(&mut instance); + c1866_l1878_action_invoke(&mut instance); + c1867_l1879_action_invoke(&mut instance); + c1868_l1880_action_invoke(&mut instance); + c1869_l1881_action_invoke(&mut instance); + c1870_l1882_action_invoke(&mut instance); + c1871_l1883_action_invoke(&mut instance); + c1872_l1884_action_invoke(&mut instance); + c1873_l1885_action_invoke(&mut instance); + c1874_l1886_action_invoke(&mut instance); + c1875_l1887_action_invoke(&mut instance); + c1876_l1888_action_invoke(&mut instance); + c1877_l1889_action_invoke(&mut instance); + c1878_l1890_action_invoke(&mut instance); + c1879_l1891_action_invoke(&mut instance); + c1880_l1892_action_invoke(&mut instance); + c1881_l1893_action_invoke(&mut instance); + c1882_l1894_action_invoke(&mut instance); + c1883_l1895_action_invoke(&mut instance); + c1884_l1896_action_invoke(&mut instance); + c1885_l1897_action_invoke(&mut instance); + c1886_l1898_action_invoke(&mut instance); + c1887_l1899_action_invoke(&mut instance); + c1888_l1900_action_invoke(&mut instance); + c1889_l1901_action_invoke(&mut instance); + c1890_l1902_action_invoke(&mut instance); + c1891_l1903_action_invoke(&mut instance); + c1892_l1904_action_invoke(&mut instance); + c1893_l1905_action_invoke(&mut instance); + c1894_l1906_action_invoke(&mut instance); + c1895_l1907_action_invoke(&mut instance); + c1896_l1908_action_invoke(&mut instance); + c1897_l1909_action_invoke(&mut instance); + c1898_l1910_action_invoke(&mut instance); + c1899_l1911_action_invoke(&mut instance); + c1900_l1912_action_invoke(&mut instance); + c1901_l1913_action_invoke(&mut instance); + c1902_l1914_action_invoke(&mut instance); + c1903_l1915_action_invoke(&mut instance); + c1904_l1916_action_invoke(&mut instance); + c1905_l1917_action_invoke(&mut instance); + c1906_l1918_action_invoke(&mut instance); + c1907_l1919_action_invoke(&mut instance); + c1908_l1920_action_invoke(&mut instance); + c1909_l1921_action_invoke(&mut instance); + c1910_l1922_action_invoke(&mut instance); + c1911_l1923_action_invoke(&mut instance); + c1912_l1924_action_invoke(&mut instance); + c1913_l1925_action_invoke(&mut instance); + c1914_l1926_action_invoke(&mut instance); + c1915_l1927_action_invoke(&mut instance); + c1916_l1928_action_invoke(&mut instance); + c1917_l1929_action_invoke(&mut instance); + c1918_l1930_action_invoke(&mut instance); + c1919_l1931_action_invoke(&mut instance); + c1920_l1932_action_invoke(&mut instance); + c1921_l1933_action_invoke(&mut instance); + c1922_l1934_action_invoke(&mut instance); + c1923_l1935_action_invoke(&mut instance); + c1924_l1936_action_invoke(&mut instance); + c1925_l1937_action_invoke(&mut instance); + c1926_l1938_action_invoke(&mut instance); + c1927_l1939_action_invoke(&mut instance); + c1928_l1940_action_invoke(&mut instance); + c1929_l1941_action_invoke(&mut instance); + c1930_l1942_action_invoke(&mut instance); + c1931_l1943_action_invoke(&mut instance); + c1932_l1944_action_invoke(&mut instance); + c1933_l1945_action_invoke(&mut instance); + c1934_l1946_action_invoke(&mut instance); + c1935_l1947_action_invoke(&mut instance); + c1936_l1948_action_invoke(&mut instance); + c1937_l1949_action_invoke(&mut instance); + c1938_l1950_action_invoke(&mut instance); + c1939_l1951_action_invoke(&mut instance); + c1940_l1952_action_invoke(&mut instance); + c1941_l1953_action_invoke(&mut instance); + c1942_l1954_action_invoke(&mut instance); + c1943_l1955_action_invoke(&mut instance); + c1944_l1956_action_invoke(&mut instance); + c1945_l1957_action_invoke(&mut instance); + c1946_l1958_action_invoke(&mut instance); + c1947_l1959_action_invoke(&mut instance); + c1948_l1960_action_invoke(&mut instance); + c1949_l1961_action_invoke(&mut instance); + c1950_l1962_action_invoke(&mut instance); + c1951_l1963_action_invoke(&mut instance); + c1952_l1964_action_invoke(&mut instance); + c1953_l1965_action_invoke(&mut instance); + c1954_l1966_action_invoke(&mut instance); + c1955_l1967_action_invoke(&mut instance); + c1956_l1968_action_invoke(&mut instance); + c1957_l1969_action_invoke(&mut instance); + c1958_l1970_action_invoke(&mut instance); + c1959_l1971_action_invoke(&mut instance); + c1960_l1972_action_invoke(&mut instance); + c1961_l1973_action_invoke(&mut instance); + c1962_l1974_action_invoke(&mut instance); + c1963_l1975_action_invoke(&mut instance); + c1964_l1976_action_invoke(&mut instance); + c1965_l1977_action_invoke(&mut instance); + c1966_l1978_action_invoke(&mut instance); + c1967_l1979_action_invoke(&mut instance); + c1968_l1980_action_invoke(&mut instance); + c1969_l1981_action_invoke(&mut instance); + c1970_l1982_action_invoke(&mut instance); + c1971_l1983_action_invoke(&mut instance); + c1972_l1984_action_invoke(&mut instance); + c1973_l1985_action_invoke(&mut instance); + c1974_l1986_action_invoke(&mut instance); + c1975_l1987_action_invoke(&mut instance); + c1976_l1988_action_invoke(&mut instance); + c1977_l1989_action_invoke(&mut instance); + c1978_l1990_action_invoke(&mut instance); + c1979_l1991_action_invoke(&mut instance); + c1980_l1992_action_invoke(&mut instance); + c1981_l1993_action_invoke(&mut instance); + c1982_l1994_action_invoke(&mut instance); + c1983_l1995_action_invoke(&mut instance); + c1984_l1996_action_invoke(&mut instance); + c1985_l1997_action_invoke(&mut instance); + c1986_l1998_action_invoke(&mut instance); + c1987_l1999_action_invoke(&mut instance); + c1988_l2000_action_invoke(&mut instance); + c1989_l2001_action_invoke(&mut instance); + c1990_l2002_action_invoke(&mut instance); + c1991_l2003_action_invoke(&mut instance); + c1992_l2004_action_invoke(&mut instance); + c1993_l2005_action_invoke(&mut instance); + c1994_l2006_action_invoke(&mut instance); + c1995_l2007_action_invoke(&mut instance); + c1996_l2008_action_invoke(&mut instance); + c1997_l2009_action_invoke(&mut instance); + c1998_l2010_action_invoke(&mut instance); + c1999_l2011_action_invoke(&mut instance); + c2000_l2012_action_invoke(&mut instance); + c2001_l2013_action_invoke(&mut instance); + c2002_l2014_action_invoke(&mut instance); + c2003_l2015_action_invoke(&mut instance); + c2004_l2016_action_invoke(&mut instance); + c2005_l2017_action_invoke(&mut instance); + c2006_l2018_action_invoke(&mut instance); + c2007_l2019_action_invoke(&mut instance); + c2008_l2020_action_invoke(&mut instance); + c2009_l2021_action_invoke(&mut instance); + c2010_l2022_action_invoke(&mut instance); + c2011_l2023_action_invoke(&mut instance); + c2012_l2024_action_invoke(&mut instance); + c2013_l2025_action_invoke(&mut instance); + c2014_l2026_action_invoke(&mut instance); + c2015_l2027_action_invoke(&mut instance); + c2016_l2028_action_invoke(&mut instance); + c2017_l2029_action_invoke(&mut instance); + c2018_l2030_action_invoke(&mut instance); + c2019_l2031_action_invoke(&mut instance); + c2020_l2032_action_invoke(&mut instance); + c2021_l2033_action_invoke(&mut instance); + c2022_l2034_action_invoke(&mut instance); + c2023_l2035_action_invoke(&mut instance); + c2024_l2036_action_invoke(&mut instance); + c2025_l2037_action_invoke(&mut instance); + c2026_l2038_action_invoke(&mut instance); + c2027_l2039_action_invoke(&mut instance); + c2028_l2040_action_invoke(&mut instance); + c2029_l2041_action_invoke(&mut instance); + c2030_l2042_action_invoke(&mut instance); + c2031_l2043_action_invoke(&mut instance); + c2032_l2044_action_invoke(&mut instance); + c2033_l2045_action_invoke(&mut instance); + c2034_l2046_action_invoke(&mut instance); + c2035_l2047_action_invoke(&mut instance); + c2036_l2048_action_invoke(&mut instance); + c2037_l2049_action_invoke(&mut instance); + c2038_l2050_action_invoke(&mut instance); + c2039_l2051_action_invoke(&mut instance); + c2040_l2052_action_invoke(&mut instance); + c2041_l2053_action_invoke(&mut instance); + c2042_l2054_action_invoke(&mut instance); + c2043_l2055_action_invoke(&mut instance); + c2044_l2056_action_invoke(&mut instance); + c2045_l2057_action_invoke(&mut instance); + c2046_l2058_action_invoke(&mut instance); + c2047_l2059_action_invoke(&mut instance); + c2048_l2060_action_invoke(&mut instance); + c2049_l2061_action_invoke(&mut instance); + c2050_l2062_action_invoke(&mut instance); + c2051_l2063_action_invoke(&mut instance); + c2052_l2064_action_invoke(&mut instance); + c2053_l2065_action_invoke(&mut instance); + c2054_l2066_action_invoke(&mut instance); + c2055_l2067_action_invoke(&mut instance); + c2056_l2068_action_invoke(&mut instance); + c2057_l2069_action_invoke(&mut instance); + c2058_l2070_action_invoke(&mut instance); + c2059_l2071_action_invoke(&mut instance); + c2060_l2072_action_invoke(&mut instance); + c2061_l2073_action_invoke(&mut instance); + c2062_l2074_action_invoke(&mut instance); + c2063_l2075_action_invoke(&mut instance); + c2064_l2076_action_invoke(&mut instance); + c2065_l2077_action_invoke(&mut instance); + c2066_l2078_action_invoke(&mut instance); + c2067_l2079_action_invoke(&mut instance); + c2068_l2080_action_invoke(&mut instance); + c2069_l2081_action_invoke(&mut instance); + c2070_l2082_action_invoke(&mut instance); + c2071_l2083_action_invoke(&mut instance); + c2072_l2084_action_invoke(&mut instance); + c2073_l2085_action_invoke(&mut instance); + c2074_l2086_action_invoke(&mut instance); + c2075_l2087_action_invoke(&mut instance); + c2076_l2088_action_invoke(&mut instance); + c2077_l2089_action_invoke(&mut instance); + c2078_l2090_action_invoke(&mut instance); + c2079_l2091_action_invoke(&mut instance); + c2080_l2092_action_invoke(&mut instance); + c2081_l2093_action_invoke(&mut instance); + c2082_l2094_action_invoke(&mut instance); + c2083_l2095_action_invoke(&mut instance); + c2084_l2096_action_invoke(&mut instance); + c2085_l2097_action_invoke(&mut instance); + c2086_l2098_action_invoke(&mut instance); + c2087_l2099_action_invoke(&mut instance); + c2088_l2100_action_invoke(&mut instance); + c2089_l2101_action_invoke(&mut instance); + c2090_l2102_action_invoke(&mut instance); + c2091_l2103_action_invoke(&mut instance); + c2092_l2104_action_invoke(&mut instance); + c2093_l2105_action_invoke(&mut instance); + c2094_l2106_action_invoke(&mut instance); + c2095_l2107_action_invoke(&mut instance); + c2096_l2108_action_invoke(&mut instance); + c2097_l2109_action_invoke(&mut instance); + c2098_l2110_action_invoke(&mut instance); + c2099_l2111_action_invoke(&mut instance); + c2100_l2112_action_invoke(&mut instance); + c2101_l2113_action_invoke(&mut instance); + c2102_l2114_action_invoke(&mut instance); + c2103_l2115_action_invoke(&mut instance); + c2104_l2116_action_invoke(&mut instance); + c2105_l2117_action_invoke(&mut instance); + c2106_l2118_action_invoke(&mut instance); + c2107_l2119_action_invoke(&mut instance); + c2108_l2120_action_invoke(&mut instance); + c2109_l2121_action_invoke(&mut instance); + c2110_l2122_action_invoke(&mut instance); + c2111_l2123_action_invoke(&mut instance); + c2112_l2124_action_invoke(&mut instance); + c2113_l2125_action_invoke(&mut instance); + c2114_l2126_action_invoke(&mut instance); + c2115_l2127_action_invoke(&mut instance); + c2116_l2128_action_invoke(&mut instance); + c2117_l2129_action_invoke(&mut instance); + c2118_l2130_action_invoke(&mut instance); + c2119_l2131_action_invoke(&mut instance); + c2120_l2132_action_invoke(&mut instance); + c2121_l2133_action_invoke(&mut instance); + c2122_l2134_action_invoke(&mut instance); + c2123_l2135_action_invoke(&mut instance); + c2124_l2136_action_invoke(&mut instance); + c2125_l2137_action_invoke(&mut instance); + c2126_l2138_action_invoke(&mut instance); + c2127_l2139_action_invoke(&mut instance); + c2128_l2140_action_invoke(&mut instance); + c2129_l2141_action_invoke(&mut instance); + c2130_l2142_action_invoke(&mut instance); + c2131_l2143_action_invoke(&mut instance); + c2132_l2144_action_invoke(&mut instance); + c2133_l2145_action_invoke(&mut instance); + c2134_l2146_action_invoke(&mut instance); + c2135_l2147_action_invoke(&mut instance); + c2136_l2148_action_invoke(&mut instance); + c2137_l2149_action_invoke(&mut instance); + c2138_l2150_action_invoke(&mut instance); + c2139_l2151_action_invoke(&mut instance); + c2140_l2152_action_invoke(&mut instance); + c2141_l2153_action_invoke(&mut instance); + c2142_l2154_action_invoke(&mut instance); + c2143_l2155_action_invoke(&mut instance); + c2144_l2156_action_invoke(&mut instance); + c2145_l2157_action_invoke(&mut instance); + c2146_l2158_action_invoke(&mut instance); + c2147_l2159_action_invoke(&mut instance); + c2148_l2160_action_invoke(&mut instance); + c2149_l2161_action_invoke(&mut instance); + c2150_l2162_action_invoke(&mut instance); + c2151_l2163_action_invoke(&mut instance); + c2152_l2164_action_invoke(&mut instance); + c2153_l2165_action_invoke(&mut instance); + c2154_l2166_action_invoke(&mut instance); + c2155_l2167_action_invoke(&mut instance); + c2156_l2168_action_invoke(&mut instance); + c2157_l2169_action_invoke(&mut instance); + c2158_l2170_action_invoke(&mut instance); + c2159_l2171_action_invoke(&mut instance); + c2160_l2172_action_invoke(&mut instance); + c2161_l2173_action_invoke(&mut instance); + c2162_l2174_action_invoke(&mut instance); + c2163_l2175_action_invoke(&mut instance); + c2164_l2176_action_invoke(&mut instance); + c2165_l2177_action_invoke(&mut instance); + c2166_l2178_action_invoke(&mut instance); + c2167_l2179_action_invoke(&mut instance); + c2168_l2180_action_invoke(&mut instance); + c2169_l2181_action_invoke(&mut instance); + c2170_l2182_action_invoke(&mut instance); + c2171_l2183_action_invoke(&mut instance); + c2172_l2184_action_invoke(&mut instance); + c2173_l2185_action_invoke(&mut instance); + c2174_l2186_action_invoke(&mut instance); + c2175_l2187_action_invoke(&mut instance); + c2176_l2188_action_invoke(&mut instance); + c2177_l2189_action_invoke(&mut instance); + c2178_l2190_action_invoke(&mut instance); + c2179_l2191_action_invoke(&mut instance); + c2180_l2192_action_invoke(&mut instance); + c2181_l2193_action_invoke(&mut instance); + c2182_l2194_action_invoke(&mut instance); + c2183_l2195_action_invoke(&mut instance); + c2184_l2196_action_invoke(&mut instance); + c2185_l2197_action_invoke(&mut instance); + c2186_l2198_action_invoke(&mut instance); + c2187_l2199_action_invoke(&mut instance); + c2188_l2200_action_invoke(&mut instance); + c2189_l2201_action_invoke(&mut instance); + c2190_l2202_action_invoke(&mut instance); + c2191_l2203_action_invoke(&mut instance); + c2192_l2204_action_invoke(&mut instance); + c2193_l2205_action_invoke(&mut instance); + c2194_l2206_action_invoke(&mut instance); + c2195_l2207_action_invoke(&mut instance); + c2196_l2208_action_invoke(&mut instance); + c2197_l2209_action_invoke(&mut instance); + c2198_l2210_action_invoke(&mut instance); + c2199_l2211_action_invoke(&mut instance); + c2200_l2212_action_invoke(&mut instance); + c2201_l2213_action_invoke(&mut instance); + c2202_l2214_action_invoke(&mut instance); + c2203_l2215_action_invoke(&mut instance); + c2204_l2216_action_invoke(&mut instance); + c2205_l2217_action_invoke(&mut instance); + c2206_l2218_action_invoke(&mut instance); + c2207_l2219_action_invoke(&mut instance); + c2208_l2220_action_invoke(&mut instance); + c2209_l2221_action_invoke(&mut instance); + c2210_l2222_action_invoke(&mut instance); + c2211_l2223_action_invoke(&mut instance); + c2212_l2224_action_invoke(&mut instance); + c2213_l2225_action_invoke(&mut instance); + c2214_l2226_action_invoke(&mut instance); + c2215_l2227_action_invoke(&mut instance); + c2216_l2228_action_invoke(&mut instance); + c2217_l2229_action_invoke(&mut instance); + c2218_l2230_action_invoke(&mut instance); + c2219_l2231_action_invoke(&mut instance); + c2220_l2232_action_invoke(&mut instance); + c2221_l2233_action_invoke(&mut instance); + c2222_l2234_action_invoke(&mut instance); + c2223_l2235_action_invoke(&mut instance); + c2224_l2236_action_invoke(&mut instance); + c2225_l2237_action_invoke(&mut instance); + c2226_l2238_action_invoke(&mut instance); + c2227_l2239_action_invoke(&mut instance); + c2228_l2240_action_invoke(&mut instance); + c2229_l2241_action_invoke(&mut instance); + c2230_l2242_action_invoke(&mut instance); + c2231_l2243_action_invoke(&mut instance); + c2232_l2244_action_invoke(&mut instance); + c2233_l2245_action_invoke(&mut instance); + c2234_l2246_action_invoke(&mut instance); + c2235_l2247_action_invoke(&mut instance); + c2236_l2248_action_invoke(&mut instance); + c2237_l2249_action_invoke(&mut instance); + c2238_l2250_action_invoke(&mut instance); + c2239_l2251_action_invoke(&mut instance); + c2240_l2252_action_invoke(&mut instance); + c2241_l2253_action_invoke(&mut instance); + c2242_l2254_action_invoke(&mut instance); + c2243_l2255_action_invoke(&mut instance); + c2244_l2256_action_invoke(&mut instance); + c2245_l2257_action_invoke(&mut instance); + c2246_l2258_action_invoke(&mut instance); + c2247_l2259_action_invoke(&mut instance); + c2248_l2260_action_invoke(&mut instance); + c2249_l2261_action_invoke(&mut instance); + c2250_l2262_action_invoke(&mut instance); + c2251_l2263_action_invoke(&mut instance); + c2252_l2264_action_invoke(&mut instance); + c2253_l2265_action_invoke(&mut instance); + c2254_l2266_action_invoke(&mut instance); + c2255_l2267_action_invoke(&mut instance); + c2256_l2268_action_invoke(&mut instance); + c2257_l2269_action_invoke(&mut instance); + c2258_l2270_action_invoke(&mut instance); + c2259_l2271_action_invoke(&mut instance); + c2260_l2272_action_invoke(&mut instance); + c2261_l2273_action_invoke(&mut instance); + c2262_l2274_action_invoke(&mut instance); + c2263_l2275_action_invoke(&mut instance); + c2264_l2276_action_invoke(&mut instance); + c2265_l2277_action_invoke(&mut instance); + c2266_l2278_action_invoke(&mut instance); + c2267_l2279_action_invoke(&mut instance); + c2268_l2280_action_invoke(&mut instance); + c2269_l2281_action_invoke(&mut instance); + c2270_l2282_action_invoke(&mut instance); + c2271_l2283_action_invoke(&mut instance); + c2272_l2284_action_invoke(&mut instance); + c2273_l2285_action_invoke(&mut instance); + c2274_l2286_action_invoke(&mut instance); + c2275_l2287_action_invoke(&mut instance); + c2276_l2288_action_invoke(&mut instance); + c2277_l2289_action_invoke(&mut instance); + c2278_l2290_action_invoke(&mut instance); + c2279_l2291_action_invoke(&mut instance); + c2280_l2292_action_invoke(&mut instance); + c2281_l2293_action_invoke(&mut instance); + c2282_l2294_action_invoke(&mut instance); + c2283_l2295_action_invoke(&mut instance); + c2284_l2296_action_invoke(&mut instance); + c2285_l2297_action_invoke(&mut instance); + c2286_l2298_action_invoke(&mut instance); + c2287_l2299_action_invoke(&mut instance); + c2288_l2300_action_invoke(&mut instance); + c2289_l2301_action_invoke(&mut instance); + c2290_l2302_action_invoke(&mut instance); + c2291_l2303_action_invoke(&mut instance); + c2292_l2304_action_invoke(&mut instance); + c2293_l2305_action_invoke(&mut instance); + c2294_l2306_action_invoke(&mut instance); + c2295_l2307_action_invoke(&mut instance); + c2296_l2308_action_invoke(&mut instance); + c2297_l2309_action_invoke(&mut instance); + c2298_l2310_action_invoke(&mut instance); + c2299_l2311_action_invoke(&mut instance); + c2300_l2312_action_invoke(&mut instance); + c2301_l2313_action_invoke(&mut instance); + c2302_l2314_action_invoke(&mut instance); + c2303_l2315_action_invoke(&mut instance); + c2304_l2316_action_invoke(&mut instance); + c2305_l2317_action_invoke(&mut instance); + c2306_l2318_action_invoke(&mut instance); + c2307_l2319_action_invoke(&mut instance); + c2308_l2320_action_invoke(&mut instance); + c2309_l2321_action_invoke(&mut instance); + c2310_l2322_action_invoke(&mut instance); + c2311_l2323_action_invoke(&mut instance); + c2312_l2324_action_invoke(&mut instance); + c2313_l2325_action_invoke(&mut instance); + c2314_l2326_action_invoke(&mut instance); + c2315_l2327_action_invoke(&mut instance); + c2316_l2328_action_invoke(&mut instance); + c2317_l2329_action_invoke(&mut instance); + c2318_l2330_action_invoke(&mut instance); + c2319_l2331_action_invoke(&mut instance); + c2320_l2332_action_invoke(&mut instance); + c2321_l2333_action_invoke(&mut instance); + c2322_l2334_action_invoke(&mut instance); + c2323_l2335_action_invoke(&mut instance); + c2324_l2336_action_invoke(&mut instance); + c2325_l2337_action_invoke(&mut instance); + c2326_l2338_action_invoke(&mut instance); + c2327_l2339_action_invoke(&mut instance); + c2328_l2340_action_invoke(&mut instance); + c2329_l2341_action_invoke(&mut instance); + c2330_l2342_action_invoke(&mut instance); + c2331_l2343_action_invoke(&mut instance); + c2332_l2344_action_invoke(&mut instance); + c2333_l2345_action_invoke(&mut instance); + c2334_l2346_action_invoke(&mut instance); + c2335_l2347_action_invoke(&mut instance); + c2336_l2348_action_invoke(&mut instance); + c2337_l2349_action_invoke(&mut instance); + c2338_l2350_action_invoke(&mut instance); + c2339_l2351_action_invoke(&mut instance); + c2340_l2352_action_invoke(&mut instance); + c2341_l2353_action_invoke(&mut instance); + c2342_l2354_action_invoke(&mut instance); + c2343_l2355_action_invoke(&mut instance); + c2344_l2356_action_invoke(&mut instance); + c2345_l2357_action_invoke(&mut instance); + c2346_l2358_action_invoke(&mut instance); + c2347_l2359_action_invoke(&mut instance); + c2348_l2360_action_invoke(&mut instance); + c2349_l2361_action_invoke(&mut instance); + c2350_l2362_action_invoke(&mut instance); + c2351_l2363_action_invoke(&mut instance); + c2352_l2364_action_invoke(&mut instance); + c2353_l2365_action_invoke(&mut instance); + c2354_l2366_action_invoke(&mut instance); + c2355_l2367_action_invoke(&mut instance); + c2356_l2368_action_invoke(&mut instance); + c2357_l2369_action_invoke(&mut instance); + c2358_l2370_action_invoke(&mut instance); + c2359_l2371_action_invoke(&mut instance); + c2360_l2372_action_invoke(&mut instance); + c2361_l2373_action_invoke(&mut instance); + c2362_l2374_action_invoke(&mut instance); + c2363_l2375_action_invoke(&mut instance); + c2364_l2376_action_invoke(&mut instance); + c2365_l2377_action_invoke(&mut instance); + c2366_l2378_action_invoke(&mut instance); + c2367_l2379_action_invoke(&mut instance); + c2368_l2380_action_invoke(&mut instance); + c2369_l2381_action_invoke(&mut instance); + c2370_l2382_action_invoke(&mut instance); + c2371_l2383_action_invoke(&mut instance); + c2372_l2384_action_invoke(&mut instance); + c2373_l2385_action_invoke(&mut instance); + c2374_l2386_action_invoke(&mut instance); + c2375_l2387_action_invoke(&mut instance); + c2376_l2388_action_invoke(&mut instance); + c2377_l2389_action_invoke(&mut instance); + c2378_l2390_action_invoke(&mut instance); + c2379_l2391_action_invoke(&mut instance); + c2380_l2392_action_invoke(&mut instance); + c2381_l2393_action_invoke(&mut instance); + c2382_l2394_action_invoke(&mut instance); + c2383_l2395_action_invoke(&mut instance); + c2384_l2396_action_invoke(&mut instance); + c2385_l2397_action_invoke(&mut instance); + c2386_l2398_action_invoke(&mut instance); + c2387_l2399_action_invoke(&mut instance); + c2388_l2400_action_invoke(&mut instance); + c2389_l2401_action_invoke(&mut instance); + c2390_l2402_action_invoke(&mut instance); + c2391_l2403_action_invoke(&mut instance); + c2392_l2404_action_invoke(&mut instance); + c2393_l2405_action_invoke(&mut instance); + c2394_l2406_action_invoke(&mut instance); + c2395_l2407_action_invoke(&mut instance); + c2396_l2408_action_invoke(&mut instance); + c2397_l2409_action_invoke(&mut instance); + c2398_l2410_action_invoke(&mut instance); + c2399_l2411_action_invoke(&mut instance); + c2400_l2412_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/fac.rs b/lib/runtime/tests/spectests/fac.rs new file mode 100644 index 000000000..772ebff58 --- /dev/null +++ b/lib/runtime/tests/spectests/fac.rs @@ -0,0 +1,200 @@ +// 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/fac.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 1 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func (param i64) (result i64))) + (func (;0;) (type 0) (param i64) (result i64) + get_local 0 + i64.const 0 + i64.eq + if (result i64) ;; label = @1 + i64.const 1 + else + get_local 0 + get_local 0 + i64.const 1 + i64.sub + call 0 + i64.mul + end) + (func (;1;) (type 0) (param i64) (result i64) + get_local 0 + i64.const 0 + i64.eq + if (result i64) ;; label = @1 + i64.const 1 + else + get_local 0 + get_local 0 + i64.const 1 + i64.sub + call 1 + i64.mul + end) + (func (;2;) (type 0) (param i64) (result i64) + (local i64 i64) + get_local 0 + set_local 1 + i64.const 1 + set_local 2 + block ;; label = @1 + loop ;; label = @2 + get_local 1 + i64.const 0 + i64.eq + if ;; label = @3 + br 2 (;@1;) + else + get_local 1 + get_local 2 + i64.mul + set_local 2 + get_local 1 + i64.const 1 + i64.sub + set_local 1 + end + br 0 (;@2;) + end + end + get_local 2) + (func (;3;) (type 0) (param i64) (result i64) + (local i64 i64) + get_local 0 + set_local 1 + i64.const 1 + set_local 2 + block ;; label = @1 + loop ;; label = @2 + get_local 1 + i64.const 0 + i64.eq + if ;; label = @3 + br 2 (;@1;) + else + get_local 1 + get_local 2 + i64.mul + set_local 2 + get_local 1 + i64.const 1 + i64.sub + set_local 1 + end + br 0 (;@2;) + end + end + get_local 2) + (func (;4;) (type 0) (param i64) (result i64) + (local i64) + i64.const 1 + set_local 1 + block ;; label = @1 + get_local 0 + i64.const 2 + i64.lt_s + br_if 0 (;@1;) + loop ;; label = @2 + get_local 1 + get_local 0 + i64.mul + set_local 1 + get_local 0 + i64.const -1 + i64.add + set_local 0 + get_local 0 + i64.const 1 + i64.gt_s + br_if 0 (;@2;) + end + end + get_local 1) + (export \"fac-rec\" (func 0)) + (export \"fac-rec-named\" (func 1)) + (export \"fac-iter\" (func 2)) + (export \"fac-iter-named\" (func 3)) + (export \"fac-opt\" (func 4))) + "; + 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 84 +fn c1_l84_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l84_action_invoke"); + let result = instance.call("fac-rec", &[Value::I64(25 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(7034535277573963776 as i64)))); + result.map(|_| ()) +} + +// Line 85 +fn c2_l85_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l85_action_invoke"); + let result = instance.call("fac-iter", &[Value::I64(25 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(7034535277573963776 as i64)))); + result.map(|_| ()) +} + +// Line 86 +fn c3_l86_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l86_action_invoke"); + let result = instance.call("fac-rec-named", &[Value::I64(25 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(7034535277573963776 as i64)))); + result.map(|_| ()) +} + +// Line 87 +fn c4_l87_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l87_action_invoke"); + let result = instance.call("fac-iter-named", &[Value::I64(25 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(7034535277573963776 as i64)))); + result.map(|_| ()) +} + +// Line 88 +fn c5_l88_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l88_action_invoke"); + let result = instance.call("fac-opt", &[Value::I64(25 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(7034535277573963776 as i64)))); + result.map(|_| ()) +} + +// Line 89 + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l84_action_invoke(&mut instance); + c2_l85_action_invoke(&mut instance); + c3_l86_action_invoke(&mut instance); + c4_l87_action_invoke(&mut instance); + c5_l88_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/float_exprs.rs b/lib/runtime/tests/spectests/float_exprs.rs new file mode 100644 index 000000000..65f012296 --- /dev/null +++ b/lib/runtime/tests/spectests/float_exprs.rs @@ -0,0 +1,12336 @@ +// 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/float_exprs.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 6 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func (param f64 f64 f64) (result f64))) + (func (;0;) (type 0) (param f64 f64 f64) (result f64) + get_local 0 + get_local 1 + f64.mul + get_local 2 + f64.add) + (export \"f64.no_contraction\" (func 0))) + "; + 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 11 +fn c1_l11_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l11_action_invoke"); + let result = instance.call("f64.no_contraction", &[Value::F64((-0.00000000000000000000000000000015967133604096234f64).to_bits()), Value::F64((87633521608271230000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((42896576204898460000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-13992561434270632000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 12 +fn c2_l12_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l12_action_invoke"); + let result = instance.call("f64.no_contraction", &[Value::F64((8341016642481988.0f64).to_bits()), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003223424965918293f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000023310835741659086f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000026886641288847496f64).to_bits())))); + result.map(|_| ()) +} + +// Line 13 +fn c3_l13_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l13_action_invoke"); + let result = instance.call("f64.no_contraction", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000030119045290520013f64).to_bits()), Value::F64((52699336439236750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.00000000000000000000000000000006654454781339856f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000015872537009936566f64).to_bits())))); + result.map(|_| ()) +} + +// Line 14 +fn c4_l14_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l14_action_invoke"); + let result = instance.call("f64.no_contraction", &[Value::F64((0.0000000000000000000031413936116780743f64).to_bits()), Value::F64((-0.0000000000000000000000000000007262766035707377f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000004619684894228461f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000228152068276836f64).to_bits())))); + result.map(|_| ()) +} + +// Line 15 +fn c5_l15_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l15_action_invoke"); + let result = instance.call("f64.no_contraction", &[Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016080464217402378f64).to_bits()), Value::F64((-382103410226833000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.00000000000000010541980504151345f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00006144400215510552f64).to_bits())))); + result.map(|_| ()) +} + +// Line 19 + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l11_action_invoke(&mut instance); + c2_l12_action_invoke(&mut instance); + c3_l13_action_invoke(&mut instance); + c4_l14_action_invoke(&mut instance); + c5_l15_action_invoke(&mut instance); +} +fn create_module_2() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32 f32) (result f32))) + (type (;1;) (func (param f64 f64 f64) (result f64))) + (func (;0;) (type 0) (param f32 f32 f32) (result f32) + get_local 0 + get_local 1 + f32.mul + get_local 2 + f32.add) + (func (;1;) (type 1) (param f64 f64 f64) (result f64) + get_local 0 + get_local 1 + f64.mul + get_local 2 + f64.add) + (export \"f32.no_fma\" (func 0)) + (export \"f64.no_fma\" (func 1))) + "; + 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_2(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 26 +fn c7_l26_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l26_action_invoke"); + let result = instance.call("f32.no_fma", &[Value::F32((35184304000000000000000000000000000000.0f32).to_bits()), Value::F32((0.00000021584361f32).to_bits()), Value::F32((259340640000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((266934960000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 27 +fn c8_l27_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l27_action_invoke"); + let result = instance.call("f32.no_fma", &[Value::F32((0.0000000071753243f32).to_bits()), Value::F32((-0.000000000000001225534f32).to_bits()), Value::F32((0.0000000000000000000000000041316436f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0000000000000000000000087894724f32).to_bits())))); + result.map(|_| ()) +} + +// Line 28 +fn c9_l28_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l28_action_invoke"); + let result = instance.call("f32.no_fma", &[Value::F32((231063440000.0f32).to_bits()), Value::F32((0.00020773262f32).to_bits()), Value::F32((1797.6421f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((48001210.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 29 +fn c10_l29_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c10_l29_action_invoke"); + let result = instance.call("f32.no_fma", &[Value::F32((0.0045542703f32).to_bits()), Value::F32((-7265493.5f32).to_bits()), Value::F32((-2.3964283f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-33091.414f32).to_bits())))); + result.map(|_| ()) +} + +// Line 30 +fn c11_l30_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c11_l30_action_invoke"); + let result = instance.call("f32.no_fma", &[Value::F32((98881730000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.0000000000000000000008570631f32).to_bits()), Value::F32((-21579143000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-84747910000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 31 +fn c12_l31_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c12_l31_action_invoke"); + let result = instance.call("f64.no_fma", &[Value::F64((789084284375179200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((4215020052117360000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-1336601081131744700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1989405000320312800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 32 +fn c13_l32_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c13_l32_action_invoke"); + let result = instance.call("f64.no_fma", &[Value::F64((5586822348009285500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.0000000000000000000000000000000000000007397302005677334f64).to_bits()), Value::F64((36567834172040920000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((4132741216029240700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 33 +fn c14_l33_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c14_l33_action_invoke"); + let result = instance.call("f64.no_fma", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014260477822274587f64).to_bits()), Value::F64((-31087632036599860000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((343269235523777630000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-4433244872049653000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 34 +fn c15_l34_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c15_l34_action_invoke"); + let result = instance.call("f64.no_fma", &[Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000809034701735478f64).to_bits()), Value::F64((-24874417850667450000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((49484765138510810.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((250727437405094720.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 35 +fn c16_l35_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c16_l35_action_invoke"); + let result = instance.call("f64.no_fma", &[Value::F64((6723256985364377.0f64).to_bits()), Value::F64((285456566692879460000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-5593839470050757000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1919197856036028600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 40 + +#[test] +fn test_module_2() { + let mut instance = create_module_2(); + // We group the calls together + start_module_2(&mut instance); + c7_l26_action_invoke(&mut instance); + c8_l27_action_invoke(&mut instance); + c9_l28_action_invoke(&mut instance); + c10_l29_action_invoke(&mut instance); + c11_l30_action_invoke(&mut instance); + c12_l31_action_invoke(&mut instance); + c13_l32_action_invoke(&mut instance); + c14_l33_action_invoke(&mut instance); + c15_l34_action_invoke(&mut instance); + c16_l35_action_invoke(&mut instance); +} +fn create_module_3() -> Box { + let module_str = "(module + (type (;0;) (func (param f32) (result f32))) + (type (;1;) (func (param f64) (result f64))) + (func (;0;) (type 0) (param f32) (result f32) + get_local 0 + f32.const 0x0p+0 (;=0;) + f32.add) + (func (;1;) (type 1) (param f64) (result f64) + get_local 0 + f64.const 0x0p+0 (;=0;) + f64.add) + (export \"f32.no_fold_add_zero\" (func 0)) + (export \"f64.no_fold_add_zero\" (func 1))) + "; + 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_3(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 47 +fn c18_l47_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c18_l47_action_invoke"); + let result = instance.call("f32.no_fold_add_zero", &[Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 48 +fn c19_l48_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c19_l48_action_invoke"); + let result = instance.call("f64.no_fold_add_zero", &[Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 49 +fn c20_l49_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c20_l49_assert_return_arithmetic_nan"); + let result = instance.call("f32.no_fold_add_zero", &[Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c20_l49_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 50 +fn c21_l50_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c21_l50_assert_return_arithmetic_nan"); + let result = instance.call("f64.no_fold_add_zero", &[Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c21_l50_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 54 + +#[test] +fn test_module_3() { + let mut instance = create_module_3(); + // We group the calls together + start_module_3(&mut instance); + c18_l47_action_invoke(&mut instance); + c19_l48_action_invoke(&mut instance); + c20_l49_assert_return_arithmetic_nan(&mut instance); + c21_l50_assert_return_arithmetic_nan(&mut instance); +} +fn create_module_4() -> Box { + let module_str = "(module + (type (;0;) (func (param f32) (result f32))) + (type (;1;) (func (param f64) (result f64))) + (func (;0;) (type 0) (param f32) (result f32) + f32.const 0x0p+0 (;=0;) + get_local 0 + f32.sub) + (func (;1;) (type 1) (param f64) (result f64) + f64.const 0x0p+0 (;=0;) + get_local 0 + f64.sub) + (export \"f32.no_fold_zero_sub\" (func 0)) + (export \"f64.no_fold_zero_sub\" (func 1))) + "; + 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_4(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 61 +fn c23_l61_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c23_l61_action_invoke"); + let result = instance.call("f32.no_fold_zero_sub", &[Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 62 +fn c24_l62_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c24_l62_action_invoke"); + let result = instance.call("f64.no_fold_zero_sub", &[Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 63 +fn c25_l63_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c25_l63_assert_return_arithmetic_nan"); + let result = instance.call("f32.no_fold_zero_sub", &[Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c25_l63_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 64 +fn c26_l64_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c26_l64_assert_return_arithmetic_nan"); + let result = instance.call("f64.no_fold_zero_sub", &[Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c26_l64_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 68 + +#[test] +fn test_module_4() { + let mut instance = create_module_4(); + // We group the calls together + start_module_4(&mut instance); + c23_l61_action_invoke(&mut instance); + c24_l62_action_invoke(&mut instance); + c25_l63_assert_return_arithmetic_nan(&mut instance); + c26_l64_assert_return_arithmetic_nan(&mut instance); +} +fn create_module_5() -> Box { + let module_str = "(module + (type (;0;) (func (param f32) (result f32))) + (type (;1;) (func (param f64) (result f64))) + (func (;0;) (type 0) (param f32) (result f32) + get_local 0 + f32.const 0x0p+0 (;=0;) + f32.sub) + (func (;1;) (type 1) (param f64) (result f64) + get_local 0 + f64.const 0x0p+0 (;=0;) + f64.sub) + (export \"f32.no_fold_sub_zero\" (func 0)) + (export \"f64.no_fold_sub_zero\" (func 1))) + "; + 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_5(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 75 +fn c28_l75_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c28_l75_assert_return_arithmetic_nan"); + let result = instance.call("f32.no_fold_sub_zero", &[Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c28_l75_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 76 +fn c29_l76_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c29_l76_assert_return_arithmetic_nan"); + let result = instance.call("f64.no_fold_sub_zero", &[Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c29_l76_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 80 + +#[test] +fn test_module_5() { + let mut instance = create_module_5(); + // We group the calls together + start_module_5(&mut instance); + c28_l75_assert_return_arithmetic_nan(&mut instance); + c29_l76_assert_return_arithmetic_nan(&mut instance); +} +fn create_module_6() -> Box { + let module_str = "(module + (type (;0;) (func (param f32) (result f32))) + (type (;1;) (func (param f64) (result f64))) + (func (;0;) (type 0) (param f32) (result f32) + get_local 0 + f32.const 0x0p+0 (;=0;) + f32.mul) + (func (;1;) (type 1) (param f64) (result f64) + get_local 0 + f64.const 0x0p+0 (;=0;) + f64.mul) + (export \"f32.no_fold_mul_zero\" (func 0)) + (export \"f64.no_fold_mul_zero\" (func 1))) + "; + 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_6(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 87 +fn c31_l87_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c31_l87_action_invoke"); + let result = instance.call("f32.no_fold_mul_zero", &[Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 88 +fn c32_l88_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c32_l88_action_invoke"); + let result = instance.call("f32.no_fold_mul_zero", &[Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 89 +fn c33_l89_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c33_l89_action_invoke"); + let result = instance.call("f32.no_fold_mul_zero", &[Value::F32((-2.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 90 +fn c34_l90_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c34_l90_assert_return_arithmetic_nan"); + let result = instance.call("f32.no_fold_mul_zero", &[Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c34_l90_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 91 +fn c35_l91_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c35_l91_action_invoke"); + let result = instance.call("f64.no_fold_mul_zero", &[Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 92 +fn c36_l92_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c36_l92_action_invoke"); + let result = instance.call("f64.no_fold_mul_zero", &[Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 93 +fn c37_l93_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c37_l93_action_invoke"); + let result = instance.call("f64.no_fold_mul_zero", &[Value::F64((-2.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 94 +fn c38_l94_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c38_l94_assert_return_arithmetic_nan"); + let result = instance.call("f64.no_fold_mul_zero", &[Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c38_l94_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 99 + +#[test] +fn test_module_6() { + let mut instance = create_module_6(); + // We group the calls together + start_module_6(&mut instance); + c31_l87_action_invoke(&mut instance); + c32_l88_action_invoke(&mut instance); + c33_l89_action_invoke(&mut instance); + c34_l90_assert_return_arithmetic_nan(&mut instance); + c35_l91_action_invoke(&mut instance); + c36_l92_action_invoke(&mut instance); + c37_l93_action_invoke(&mut instance); + c38_l94_assert_return_arithmetic_nan(&mut instance); +} +fn create_module_7() -> Box { + let module_str = "(module + (type (;0;) (func (param f32) (result f32))) + (type (;1;) (func (param f64) (result f64))) + (func (;0;) (type 0) (param f32) (result f32) + get_local 0 + f32.const 0x1p+0 (;=1;) + f32.mul) + (func (;1;) (type 1) (param f64) (result f64) + get_local 0 + f64.const 0x1p+0 (;=1;) + f64.mul) + (export \"f32.no_fold_mul_one\" (func 0)) + (export \"f64.no_fold_mul_one\" (func 1))) + "; + 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_7(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 106 +fn c40_l106_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c40_l106_assert_return_arithmetic_nan"); + let result = instance.call("f32.no_fold_mul_one", &[Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c40_l106_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 107 +fn c41_l107_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c41_l107_assert_return_arithmetic_nan"); + let result = instance.call("f64.no_fold_mul_one", &[Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c41_l107_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 111 + +#[test] +fn test_module_7() { + let mut instance = create_module_7(); + // We group the calls together + start_module_7(&mut instance); + c40_l106_assert_return_arithmetic_nan(&mut instance); + c41_l107_assert_return_arithmetic_nan(&mut instance); +} +fn create_module_8() -> Box { + let module_str = "(module + (type (;0;) (func (param f32) (result f32))) + (type (;1;) (func (param f64) (result f64))) + (func (;0;) (type 0) (param f32) (result f32) + f32.const 0x0p+0 (;=0;) + get_local 0 + f32.div) + (func (;1;) (type 1) (param f64) (result f64) + f64.const 0x0p+0 (;=0;) + get_local 0 + f64.div) + (export \"f32.no_fold_zero_div\" (func 0)) + (export \"f64.no_fold_zero_div\" (func 1))) + "; + 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_8(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 118 +fn c43_l118_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c43_l118_assert_return_canonical_nan"); + let result = instance.call("f32.no_fold_zero_div", &[Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c43_l118_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 119 +fn c44_l119_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c44_l119_assert_return_canonical_nan"); + let result = instance.call("f32.no_fold_zero_div", &[Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c44_l119_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 120 +fn c45_l120_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c45_l120_assert_return_canonical_nan"); + let result = instance.call("f32.no_fold_zero_div", &[Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c45_l120_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 121 +fn c46_l121_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c46_l121_assert_return_arithmetic_nan"); + let result = instance.call("f32.no_fold_zero_div", &[Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c46_l121_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 122 +fn c47_l122_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c47_l122_assert_return_canonical_nan"); + let result = instance.call("f64.no_fold_zero_div", &[Value::F64((0.0f64).to_bits())]).unwrap().expect("Missing result in c47_l122_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 123 +fn c48_l123_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c48_l123_assert_return_canonical_nan"); + let result = instance.call("f64.no_fold_zero_div", &[Value::F64((-0.0f64).to_bits())]).unwrap().expect("Missing result in c48_l123_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 124 +fn c49_l124_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c49_l124_assert_return_canonical_nan"); + let result = instance.call("f64.no_fold_zero_div", &[Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c49_l124_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 125 +fn c50_l125_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c50_l125_assert_return_arithmetic_nan"); + let result = instance.call("f64.no_fold_zero_div", &[Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c50_l125_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 129 + +#[test] +fn test_module_8() { + let mut instance = create_module_8(); + // We group the calls together + start_module_8(&mut instance); + c43_l118_assert_return_canonical_nan(&mut instance); + c44_l119_assert_return_canonical_nan(&mut instance); + c45_l120_assert_return_canonical_nan(&mut instance); + c46_l121_assert_return_arithmetic_nan(&mut instance); + c47_l122_assert_return_canonical_nan(&mut instance); + c48_l123_assert_return_canonical_nan(&mut instance); + c49_l124_assert_return_canonical_nan(&mut instance); + c50_l125_assert_return_arithmetic_nan(&mut instance); +} +fn create_module_9() -> Box { + let module_str = "(module + (type (;0;) (func (param f32) (result f32))) + (type (;1;) (func (param f64) (result f64))) + (func (;0;) (type 0) (param f32) (result f32) + get_local 0 + f32.const 0x1p+0 (;=1;) + f32.div) + (func (;1;) (type 1) (param f64) (result f64) + get_local 0 + f64.const 0x1p+0 (;=1;) + f64.div) + (export \"f32.no_fold_div_one\" (func 0)) + (export \"f64.no_fold_div_one\" (func 1))) + "; + 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_9(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 136 +fn c52_l136_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c52_l136_assert_return_arithmetic_nan"); + let result = instance.call("f32.no_fold_div_one", &[Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c52_l136_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 137 +fn c53_l137_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c53_l137_assert_return_arithmetic_nan"); + let result = instance.call("f64.no_fold_div_one", &[Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c53_l137_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 141 + +#[test] +fn test_module_9() { + let mut instance = create_module_9(); + // We group the calls together + start_module_9(&mut instance); + c52_l136_assert_return_arithmetic_nan(&mut instance); + c53_l137_assert_return_arithmetic_nan(&mut instance); +} +fn create_module_10() -> Box { + let module_str = "(module + (type (;0;) (func (param f32) (result f32))) + (type (;1;) (func (param f64) (result f64))) + (func (;0;) (type 0) (param f32) (result f32) + get_local 0 + f32.const -0x1p+0 (;=-1;) + f32.div) + (func (;1;) (type 1) (param f64) (result f64) + get_local 0 + f64.const -0x1p+0 (;=-1;) + f64.div) + (export \"f32.no_fold_div_neg1\" (func 0)) + (export \"f64.no_fold_div_neg1\" (func 1))) + "; + 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_10(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 148 +fn c55_l148_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c55_l148_assert_return_arithmetic_nan"); + let result = instance.call("f32.no_fold_div_neg1", &[Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c55_l148_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 149 +fn c56_l149_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c56_l149_assert_return_arithmetic_nan"); + let result = instance.call("f64.no_fold_div_neg1", &[Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c56_l149_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 153 + +#[test] +fn test_module_10() { + let mut instance = create_module_10(); + // We group the calls together + start_module_10(&mut instance); + c55_l148_assert_return_arithmetic_nan(&mut instance); + c56_l149_assert_return_arithmetic_nan(&mut instance); +} +fn create_module_11() -> Box { + let module_str = "(module + (type (;0;) (func (param f32) (result f32))) + (type (;1;) (func (param f64) (result f64))) + (func (;0;) (type 0) (param f32) (result f32) + f32.const -0x0p+0 (;=-0;) + get_local 0 + f32.sub) + (func (;1;) (type 1) (param f64) (result f64) + f64.const -0x0p+0 (;=-0;) + get_local 0 + f64.sub) + (export \"f32.no_fold_neg0_sub\" (func 0)) + (export \"f64.no_fold_neg0_sub\" (func 1))) + "; + 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_11(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 160 +fn c58_l160_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c58_l160_assert_return_arithmetic_nan"); + let result = instance.call("f32.no_fold_neg0_sub", &[Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c58_l160_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 161 +fn c59_l161_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c59_l161_assert_return_arithmetic_nan"); + let result = instance.call("f64.no_fold_neg0_sub", &[Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c59_l161_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 165 + +#[test] +fn test_module_11() { + let mut instance = create_module_11(); + // We group the calls together + start_module_11(&mut instance); + c58_l160_assert_return_arithmetic_nan(&mut instance); + c59_l161_assert_return_arithmetic_nan(&mut instance); +} +fn create_module_12() -> Box { + let module_str = "(module + (type (;0;) (func (param f32) (result f32))) + (type (;1;) (func (param f64) (result f64))) + (func (;0;) (type 0) (param f32) (result f32) + f32.const -0x1p+0 (;=-1;) + get_local 0 + f32.mul) + (func (;1;) (type 1) (param f64) (result f64) + f64.const -0x1p+0 (;=-1;) + get_local 0 + f64.mul) + (export \"f32.no_fold_neg1_mul\" (func 0)) + (export \"f64.no_fold_neg1_mul\" (func 1))) + "; + 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_12(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 172 +fn c61_l172_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c61_l172_assert_return_arithmetic_nan"); + let result = instance.call("f32.no_fold_neg1_mul", &[Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c61_l172_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 173 +fn c62_l173_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c62_l173_assert_return_arithmetic_nan"); + let result = instance.call("f64.no_fold_neg1_mul", &[Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c62_l173_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 177 + +#[test] +fn test_module_12() { + let mut instance = create_module_12(); + // We group the calls together + start_module_12(&mut instance); + c61_l172_assert_return_arithmetic_nan(&mut instance); + c62_l173_assert_return_arithmetic_nan(&mut instance); +} +fn create_module_13() -> Box { + let module_str = "(module + (type (;0;) (func (param f32) (result i32))) + (type (;1;) (func (param f64) (result i32))) + (func (;0;) (type 0) (param f32) (result i32) + get_local 0 + get_local 0 + f32.eq) + (func (;1;) (type 1) (param f64) (result i32) + get_local 0 + get_local 0 + f64.eq) + (export \"f32.no_fold_eq_self\" (func 0)) + (export \"f64.no_fold_eq_self\" (func 1))) + "; + 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_13(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 184 +fn c64_l184_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c64_l184_action_invoke"); + let result = instance.call("f32.no_fold_eq_self", &[Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 185 +fn c65_l185_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c65_l185_action_invoke"); + let result = instance.call("f64.no_fold_eq_self", &[Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 189 + +#[test] +fn test_module_13() { + let mut instance = create_module_13(); + // We group the calls together + start_module_13(&mut instance); + c64_l184_action_invoke(&mut instance); + c65_l185_action_invoke(&mut instance); +} +fn create_module_14() -> Box { + let module_str = "(module + (type (;0;) (func (param f32) (result i32))) + (type (;1;) (func (param f64) (result i32))) + (func (;0;) (type 0) (param f32) (result i32) + get_local 0 + get_local 0 + f32.ne) + (func (;1;) (type 1) (param f64) (result i32) + get_local 0 + get_local 0 + f64.ne) + (export \"f32.no_fold_ne_self\" (func 0)) + (export \"f64.no_fold_ne_self\" (func 1))) + "; + 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_14(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 196 +fn c67_l196_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c67_l196_action_invoke"); + let result = instance.call("f32.no_fold_ne_self", &[Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 197 +fn c68_l197_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c68_l197_action_invoke"); + let result = instance.call("f64.no_fold_ne_self", &[Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 201 + +#[test] +fn test_module_14() { + let mut instance = create_module_14(); + // We group the calls together + start_module_14(&mut instance); + c67_l196_action_invoke(&mut instance); + c68_l197_action_invoke(&mut instance); +} +fn create_module_15() -> Box { + let module_str = "(module + (type (;0;) (func (param f32) (result f32))) + (type (;1;) (func (param f64) (result f64))) + (func (;0;) (type 0) (param f32) (result f32) + get_local 0 + get_local 0 + f32.sub) + (func (;1;) (type 1) (param f64) (result f64) + get_local 0 + get_local 0 + f64.sub) + (export \"f32.no_fold_sub_self\" (func 0)) + (export \"f64.no_fold_sub_self\" (func 1))) + "; + 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_15(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 208 +fn c70_l208_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c70_l208_assert_return_canonical_nan"); + let result = instance.call("f32.no_fold_sub_self", &[Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c70_l208_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 209 +fn c71_l209_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c71_l209_assert_return_canonical_nan"); + let result = instance.call("f32.no_fold_sub_self", &[Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c71_l209_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 210 +fn c72_l210_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c72_l210_assert_return_canonical_nan"); + let result = instance.call("f64.no_fold_sub_self", &[Value::F64(f64::INFINITY.to_bits())]).unwrap().expect("Missing result in c72_l210_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 211 +fn c73_l211_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c73_l211_assert_return_canonical_nan"); + let result = instance.call("f64.no_fold_sub_self", &[Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c73_l211_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 215 + +#[test] +fn test_module_15() { + let mut instance = create_module_15(); + // We group the calls together + start_module_15(&mut instance); + c70_l208_assert_return_canonical_nan(&mut instance); + c71_l209_assert_return_canonical_nan(&mut instance); + c72_l210_assert_return_canonical_nan(&mut instance); + c73_l211_assert_return_canonical_nan(&mut instance); +} +fn create_module_16() -> Box { + let module_str = "(module + (type (;0;) (func (param f32) (result f32))) + (type (;1;) (func (param f64) (result f64))) + (func (;0;) (type 0) (param f32) (result f32) + get_local 0 + get_local 0 + f32.div) + (func (;1;) (type 1) (param f64) (result f64) + get_local 0 + get_local 0 + f64.div) + (export \"f32.no_fold_div_self\" (func 0)) + (export \"f64.no_fold_div_self\" (func 1))) + "; + 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_16(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 222 +fn c75_l222_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c75_l222_assert_return_canonical_nan"); + let result = instance.call("f32.no_fold_div_self", &[Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c75_l222_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 223 +fn c76_l223_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c76_l223_assert_return_canonical_nan"); + let result = instance.call("f32.no_fold_div_self", &[Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c76_l223_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 224 +fn c77_l224_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c77_l224_assert_return_canonical_nan"); + let result = instance.call("f32.no_fold_div_self", &[Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c77_l224_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 225 +fn c78_l225_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c78_l225_assert_return_canonical_nan"); + let result = instance.call("f32.no_fold_div_self", &[Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c78_l225_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 226 +fn c79_l226_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c79_l226_assert_return_canonical_nan"); + let result = instance.call("f64.no_fold_div_self", &[Value::F64(f64::INFINITY.to_bits())]).unwrap().expect("Missing result in c79_l226_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 227 +fn c80_l227_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c80_l227_assert_return_canonical_nan"); + let result = instance.call("f64.no_fold_div_self", &[Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c80_l227_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 228 +fn c81_l228_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c81_l228_assert_return_canonical_nan"); + let result = instance.call("f64.no_fold_div_self", &[Value::F64((0.0f64).to_bits())]).unwrap().expect("Missing result in c81_l228_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 229 +fn c82_l229_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c82_l229_assert_return_canonical_nan"); + let result = instance.call("f64.no_fold_div_self", &[Value::F64((-0.0f64).to_bits())]).unwrap().expect("Missing result in c82_l229_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 233 + +#[test] +fn test_module_16() { + let mut instance = create_module_16(); + // We group the calls together + start_module_16(&mut instance); + c75_l222_assert_return_canonical_nan(&mut instance); + c76_l223_assert_return_canonical_nan(&mut instance); + c77_l224_assert_return_canonical_nan(&mut instance); + c78_l225_assert_return_canonical_nan(&mut instance); + c79_l226_assert_return_canonical_nan(&mut instance); + c80_l227_assert_return_canonical_nan(&mut instance); + c81_l228_assert_return_canonical_nan(&mut instance); + c82_l229_assert_return_canonical_nan(&mut instance); +} +fn create_module_17() -> Box { + let module_str = "(module + (type (;0;) (func (param f32) (result f32))) + (type (;1;) (func (param f64) (result f64))) + (func (;0;) (type 0) (param f32) (result f32) + get_local 0 + f32.const 0x1.8p+1 (;=3;) + f32.div) + (func (;1;) (type 1) (param f64) (result f64) + get_local 0 + f64.const 0x1.8p+1 (;=3;) + f64.div) + (export \"f32.no_fold_div_3\" (func 0)) + (export \"f64.no_fold_div_3\" (func 1))) + "; + 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_17(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 240 +fn c84_l240_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c84_l240_action_invoke"); + let result = instance.call("f32.no_fold_div_3", &[Value::F32((-1361679000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-453892980000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 241 +fn c85_l241_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c85_l241_action_invoke"); + let result = instance.call("f32.no_fold_div_3", &[Value::F32((-18736880000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6245626600000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 242 +fn c86_l242_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c86_l242_action_invoke"); + let result = instance.call("f32.no_fold_div_3", &[Value::F32((-0.00000000000000000000000012045131f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000040150435f32).to_bits())))); + result.map(|_| ()) +} + +// Line 243 +fn c87_l243_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c87_l243_action_invoke"); + let result = instance.call("f32.no_fold_div_3", &[Value::F32((-0.00000000000000000000000000000000000005281346f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000017604486f32).to_bits())))); + result.map(|_| ()) +} + +// Line 244 +fn c88_l244_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c88_l244_action_invoke"); + let result = instance.call("f32.no_fold_div_3", &[Value::F32((-0.000000000000000025495563f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000008498521f32).to_bits())))); + result.map(|_| ()) +} + +// Line 245 +fn c89_l245_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c89_l245_action_invoke"); + let result = instance.call("f64.no_fold_div_3", &[Value::F64((-29563579573969634000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-9854526524656545000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 246 +fn c90_l246_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c90_l246_action_invoke"); + let result = instance.call("f64.no_fold_div_3", &[Value::F64((-0.000000000000000000000000000000000000000000000000009291150921449772f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000003097050307149924f64).to_bits())))); + result.map(|_| ()) +} + +// Line 247 +fn c91_l247_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c91_l247_action_invoke"); + let result = instance.call("f64.no_fold_div_3", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013808061543557006f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004602687181185669f64).to_bits())))); + result.map(|_| ()) +} + +// Line 248 +fn c92_l248_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c92_l248_action_invoke"); + let result = instance.call("f64.no_fold_div_3", &[Value::F64((-1378076163468349000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-459358721156116300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 249 +fn c93_l249_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c93_l249_action_invoke"); + let result = instance.call("f64.no_fold_div_3", &[Value::F64((86324008088313660000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((28774669362771220000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 253 + +#[test] +fn test_module_17() { + let mut instance = create_module_17(); + // We group the calls together + start_module_17(&mut instance); + c84_l240_action_invoke(&mut instance); + c85_l241_action_invoke(&mut instance); + c86_l242_action_invoke(&mut instance); + c87_l243_action_invoke(&mut instance); + c88_l244_action_invoke(&mut instance); + c89_l245_action_invoke(&mut instance); + c90_l246_action_invoke(&mut instance); + c91_l247_action_invoke(&mut instance); + c92_l248_action_invoke(&mut instance); + c93_l249_action_invoke(&mut instance); +} +fn create_module_18() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32 f32) (result f32))) + (type (;1;) (func (param f64 f64 f64) (result f64))) + (func (;0;) (type 0) (param f32 f32 f32) (result f32) + get_local 0 + get_local 2 + f32.mul + get_local 1 + get_local 2 + f32.mul + f32.add) + (func (;1;) (type 1) (param f64 f64 f64) (result f64) + get_local 0 + get_local 2 + f64.mul + get_local 1 + get_local 2 + f64.mul + f64.add) + (export \"f32.no_factor\" (func 0)) + (export \"f64.no_factor\" (func 1))) + "; + 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_18(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 260 +fn c95_l260_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c95_l260_action_invoke"); + let result = instance.call("f32.no_factor", &[Value::F32((-1435111700000.0f32).to_bits()), Value::F32((-853617640000000.0f32).to_bits()), Value::F32((1113849300000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-952399900000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 261 +fn c96_l261_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c96_l261_action_invoke"); + let result = instance.call("f32.no_factor", &[Value::F32((-0.026666632f32).to_bits()), Value::F32((0.048412822f32).to_bits()), Value::F32((-0.002813697f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0000611872f32).to_bits())))); + result.map(|_| ()) +} + +// Line 262 +fn c97_l262_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c97_l262_action_invoke"); + let result = instance.call("f32.no_factor", &[Value::F32((-0.00000000000046619777f32).to_bits()), Value::F32((0.00000000000000000010478377f32).to_bits()), Value::F32((14469202000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6745508000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 263 +fn c98_l263_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c98_l263_action_invoke"); + let result = instance.call("f32.no_factor", &[Value::F32((-0.00000000000000000010689046f32).to_bits()), Value::F32((0.00000000000000000000000010694433f32).to_bits()), Value::F32((568307000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-60746540000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 264 +fn c99_l264_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c99_l264_action_invoke"); + let result = instance.call("f32.no_factor", &[Value::F32((-0.000000000000000000000000063545994f32).to_bits()), Value::F32((0.0000000000000000000007524625f32).to_bits()), Value::F32((1626770.3f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0000000000000012239803f32).to_bits())))); + result.map(|_| ()) +} + +// Line 265 +fn c100_l265_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c100_l265_action_invoke"); + let result = instance.call("f64.no_factor", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000028390554709988774f64).to_bits()), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001473981250649641f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000029001229846550766f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008233610026197336f64).to_bits())))); + result.map(|_| ()) +} + +// Line 266 +fn c101_l266_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c101_l266_action_invoke"); + let result = instance.call("f64.no_factor", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006461015505916123f64).to_bits()), Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000023923242802975938f64).to_bits()), Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015300738798561604f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 267 +fn c102_l267_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c102_l267_action_invoke"); + let result = instance.call("f64.no_factor", &[Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002939056292080733f64).to_bits()), Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000002146156743463356f64).to_bits()), Value::F64((-2510967223130241600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((538892923853642600000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 268 +fn c103_l268_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c103_l268_action_invoke"); + let result = instance.call("f64.no_factor", &[Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000017785466771708878f64).to_bits()), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000009328516775403213f64).to_bits()), Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000012121009044876735f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001130710359943689f64).to_bits())))); + result.map(|_| ()) +} + +// Line 269 +fn c104_l269_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c104_l269_action_invoke"); + let result = instance.call("f64.no_factor", &[Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015194859063177362f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000883589921438065f64).to_bits()), Value::F64((-1735830019469195800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000000000000015337619131701908f64).to_bits())))); + result.map(|_| ()) +} + +// Line 273 + +#[test] +fn test_module_18() { + let mut instance = create_module_18(); + // We group the calls together + start_module_18(&mut instance); + c95_l260_action_invoke(&mut instance); + c96_l261_action_invoke(&mut instance); + c97_l262_action_invoke(&mut instance); + c98_l263_action_invoke(&mut instance); + c99_l264_action_invoke(&mut instance); + c100_l265_action_invoke(&mut instance); + c101_l266_action_invoke(&mut instance); + c102_l267_action_invoke(&mut instance); + c103_l268_action_invoke(&mut instance); + c104_l269_action_invoke(&mut instance); +} +fn create_module_19() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32 f32) (result f32))) + (type (;1;) (func (param f64 f64 f64) (result f64))) + (func (;0;) (type 0) (param f32 f32 f32) (result f32) + get_local 0 + get_local 1 + f32.add + get_local 2 + f32.mul) + (func (;1;) (type 1) (param f64 f64 f64) (result f64) + get_local 0 + get_local 1 + f64.add + get_local 2 + f64.mul) + (export \"f32.no_distribute\" (func 0)) + (export \"f64.no_distribute\" (func 1))) + "; + 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_19(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 280 +fn c106_l280_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c106_l280_action_invoke"); + let result = instance.call("f32.no_distribute", &[Value::F32((-1435111700000.0f32).to_bits()), Value::F32((-853617640000000.0f32).to_bits()), Value::F32((1113849300000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-952400000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 281 +fn c107_l281_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c107_l281_action_invoke"); + let result = instance.call("f32.no_distribute", &[Value::F32((-0.026666632f32).to_bits()), Value::F32((0.048412822f32).to_bits()), Value::F32((-0.002813697f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000061187195f32).to_bits())))); + result.map(|_| ()) +} + +// Line 282 +fn c108_l282_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c108_l282_action_invoke"); + let result = instance.call("f32.no_distribute", &[Value::F32((-0.00000000000046619777f32).to_bits()), Value::F32((0.00000000000000000010478377f32).to_bits()), Value::F32((14469202000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6745508500000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 283 +fn c109_l283_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c109_l283_action_invoke"); + let result = instance.call("f32.no_distribute", &[Value::F32((-0.00000000000000000010689046f32).to_bits()), Value::F32((0.00000000000000000000000010694433f32).to_bits()), Value::F32((568307000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-60746536000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 284 +fn c110_l284_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c110_l284_action_invoke"); + let result = instance.call("f32.no_distribute", &[Value::F32((-0.000000000000000000000000063545994f32).to_bits()), Value::F32((0.0000000000000000000007524625f32).to_bits()), Value::F32((1626770.3f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0000000000000012239802f32).to_bits())))); + result.map(|_| ()) +} + +// Line 285 +fn c111_l285_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c111_l285_action_invoke"); + let result = instance.call("f64.no_distribute", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000028390554709988774f64).to_bits()), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001473981250649641f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000029001229846550766f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008233610026197337f64).to_bits())))); + result.map(|_| ()) +} + +// Line 286 +fn c112_l286_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c112_l286_action_invoke"); + let result = instance.call("f64.no_distribute", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006461015505916123f64).to_bits()), Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000023923242802975938f64).to_bits()), Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015300738798561604f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 287 +fn c113_l287_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c113_l287_action_invoke"); + let result = instance.call("f64.no_distribute", &[Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002939056292080733f64).to_bits()), Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000002146156743463356f64).to_bits()), Value::F64((-2510967223130241600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((538892923853642500000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 288 +fn c114_l288_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c114_l288_action_invoke"); + let result = instance.call("f64.no_distribute", &[Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000017785466771708878f64).to_bits()), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000009328516775403213f64).to_bits()), Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000012121009044876735f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011307103599436889f64).to_bits())))); + result.map(|_| ()) +} + +// Line 289 +fn c115_l289_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c115_l289_action_invoke"); + let result = instance.call("f64.no_distribute", &[Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015194859063177362f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000883589921438065f64).to_bits()), Value::F64((-1735830019469195800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000000000000015337619131701907f64).to_bits())))); + result.map(|_| ()) +} + +// Line 293 + +#[test] +fn test_module_19() { + let mut instance = create_module_19(); + // We group the calls together + start_module_19(&mut instance); + c106_l280_action_invoke(&mut instance); + c107_l281_action_invoke(&mut instance); + c108_l282_action_invoke(&mut instance); + c109_l283_action_invoke(&mut instance); + c110_l284_action_invoke(&mut instance); + c111_l285_action_invoke(&mut instance); + c112_l286_action_invoke(&mut instance); + c113_l287_action_invoke(&mut instance); + c114_l288_action_invoke(&mut instance); + c115_l289_action_invoke(&mut instance); +} +fn create_module_20() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32 f32) (result f32))) + (type (;1;) (func (param f64 f64 f64) (result f64))) + (func (;0;) (type 0) (param f32 f32 f32) (result f32) + get_local 0 + get_local 1 + get_local 2 + f32.div + f32.mul) + (func (;1;) (type 1) (param f64 f64 f64) (result f64) + get_local 0 + get_local 1 + get_local 2 + f64.div + f64.mul) + (export \"f32.no_regroup_div_mul\" (func 0)) + (export \"f64.no_regroup_div_mul\" (func 1))) + "; + 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_20(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 300 +fn c117_l300_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c117_l300_action_invoke"); + let result = instance.call("f32.no_regroup_div_mul", &[Value::F32((-0.00000000000000000000000000000000002831349f32).to_bits()), Value::F32((-0.00000000000000000007270787f32).to_bits()), Value::F32((0.000000000000000000000000000000000016406605f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000012547468f32).to_bits())))); + result.map(|_| ()) +} + +// Line 301 +fn c118_l301_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c118_l301_action_invoke"); + let result = instance.call("f32.no_regroup_div_mul", &[Value::F32((-3145897700000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000040864003f32).to_bits()), Value::F32((-9245928300000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 302 +fn c119_l302_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c119_l302_action_invoke"); + let result = instance.call("f32.no_regroup_div_mul", &[Value::F32((-93157.43f32).to_bits()), Value::F32((-0.00000081292654f32).to_bits()), Value::F32((-0.00000000000000000000000000000000000015469397f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-489548120000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 303 +fn c120_l303_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c120_l303_action_invoke"); + let result = instance.call("f32.no_regroup_div_mul", &[Value::F32((-0.00000000000000000000000000008899643f32).to_bits()), Value::F32((17887725000000000000000.0f32).to_bits()), Value::F32((514680230000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000003093073f32).to_bits())))); + result.map(|_| ()) +} + +// Line 304 +fn c121_l304_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c121_l304_action_invoke"); + let result = instance.call("f32.no_regroup_div_mul", &[Value::F32((9222036000000000000000000000000000.0f32).to_bits()), Value::F32((33330492.0f32).to_bits()), Value::F32((-3253108800000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-94486550000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 305 +fn c122_l305_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c122_l305_action_invoke"); + let result = instance.call("f64.no_regroup_div_mul", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005698811412550059f64).to_bits()), Value::F64((-0.0000000000000000000000000000000000018313439132919336f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009543270551003098f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1093596114413331000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 306 +fn c123_l306_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c123_l306_action_invoke"); + let result = instance.call("f64.no_regroup_div_mul", &[Value::F64((357289288425507550000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003952760844538651f64).to_bits()), Value::F64((-1450781241254900800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 307 +fn c124_l307_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c124_l307_action_invoke"); + let result = instance.call("f64.no_regroup_div_mul", &[Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009124278383497107f64).to_bits()), Value::F64((55561345277147970000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000025090826940306507f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 308 +fn c125_l308_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c125_l308_action_invoke"); + let result = instance.call("f64.no_regroup_div_mul", &[Value::F64((-4492093000352015000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-12087878984017852000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-596613380626062300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-91013507803376260000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 309 +fn c126_l309_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c126_l309_action_invoke"); + let result = instance.call("f64.no_regroup_div_mul", &[Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007470269158630455f64).to_bits()), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007568026329781282f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001055389683973521f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005356807494101561f64).to_bits())))); + result.map(|_| ()) +} + +// Line 313 + +#[test] +fn test_module_20() { + let mut instance = create_module_20(); + // We group the calls together + start_module_20(&mut instance); + c117_l300_action_invoke(&mut instance); + c118_l301_action_invoke(&mut instance); + c119_l302_action_invoke(&mut instance); + c120_l303_action_invoke(&mut instance); + c121_l304_action_invoke(&mut instance); + c122_l305_action_invoke(&mut instance); + c123_l306_action_invoke(&mut instance); + c124_l307_action_invoke(&mut instance); + c125_l308_action_invoke(&mut instance); + c126_l309_action_invoke(&mut instance); +} +fn create_module_21() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32 f32) (result f32))) + (type (;1;) (func (param f64 f64 f64) (result f64))) + (func (;0;) (type 0) (param f32 f32 f32) (result f32) + get_local 0 + get_local 1 + f32.mul + get_local 2 + f32.div) + (func (;1;) (type 1) (param f64 f64 f64) (result f64) + get_local 0 + get_local 1 + f64.mul + get_local 2 + f64.div) + (export \"f32.no_regroup_mul_div\" (func 0)) + (export \"f64.no_regroup_mul_div\" (func 1))) + "; + 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_21(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 320 +fn c128_l320_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c128_l320_action_invoke"); + let result = instance.call("f32.no_regroup_mul_div", &[Value::F32((-0.00000000000000000000000000000000002831349f32).to_bits()), Value::F32((-0.00000000000000000007270787f32).to_bits()), Value::F32((0.000000000000000000000000000000000016406605f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 321 +fn c129_l321_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c129_l321_action_invoke"); + let result = instance.call("f32.no_regroup_mul_div", &[Value::F32((-3145897700000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000040864003f32).to_bits()), Value::F32((-9245928300000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000013903848f32).to_bits())))); + result.map(|_| ()) +} + +// Line 322 +fn c130_l322_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c130_l322_action_invoke"); + let result = instance.call("f32.no_regroup_mul_div", &[Value::F32((-93157.43f32).to_bits()), Value::F32((-0.00000081292654f32).to_bits()), Value::F32((-0.00000000000000000000000000000000000015469397f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-489548160000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 323 +fn c131_l323_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c131_l323_action_invoke"); + let result = instance.call("f32.no_regroup_mul_div", &[Value::F32((-0.00000000000000000000000000008899643f32).to_bits()), Value::F32((17887725000000000000000.0f32).to_bits()), Value::F32((514680230000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0000000000000000000000000030930732f32).to_bits())))); + result.map(|_| ()) +} + +// Line 324 +fn c132_l324_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c132_l324_action_invoke"); + let result = instance.call("f32.no_regroup_mul_div", &[Value::F32((9222036000000000000000000000000000.0f32).to_bits()), Value::F32((33330492.0f32).to_bits()), Value::F32((-3253108800000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 325 +fn c133_l325_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c133_l325_action_invoke"); + let result = instance.call("f64.no_regroup_mul_div", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005698811412550059f64).to_bits()), Value::F64((-0.0000000000000000000000000000000000018313439132919336f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009543270551003098f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1093596114413331100000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 326 +fn c134_l326_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c134_l326_action_invoke"); + let result = instance.call("f64.no_regroup_mul_div", &[Value::F64((357289288425507550000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003952760844538651f64).to_bits()), Value::F64((-1450781241254900800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009734611044734945f64).to_bits())))); + result.map(|_| ()) +} + +// Line 327 +fn c135_l327_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c135_l327_action_invoke"); + let result = instance.call("f64.no_regroup_mul_div", &[Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009124278383497107f64).to_bits()), Value::F64((55561345277147970000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000025090826940306507f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((20204881364667663000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 328 +fn c136_l328_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c136_l328_action_invoke"); + let result = instance.call("f64.no_regroup_mul_div", &[Value::F64((-4492093000352015000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-12087878984017852000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-596613380626062300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 329 +fn c137_l329_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c137_l329_action_invoke"); + let result = instance.call("f64.no_regroup_mul_div", &[Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007470269158630455f64).to_bits()), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007568026329781282f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001055389683973521f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 333 + +#[test] +fn test_module_21() { + let mut instance = create_module_21(); + // We group the calls together + start_module_21(&mut instance); + c128_l320_action_invoke(&mut instance); + c129_l321_action_invoke(&mut instance); + c130_l322_action_invoke(&mut instance); + c131_l323_action_invoke(&mut instance); + c132_l324_action_invoke(&mut instance); + c133_l325_action_invoke(&mut instance); + c134_l326_action_invoke(&mut instance); + c135_l327_action_invoke(&mut instance); + c136_l328_action_invoke(&mut instance); + c137_l329_action_invoke(&mut instance); +} +fn create_module_22() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32 f32 f32) (result f32))) + (type (;1;) (func (param f64 f64 f64 f64) (result f64))) + (func (;0;) (type 0) (param f32 f32 f32 f32) (result f32) + get_local 0 + get_local 1 + f32.add + get_local 2 + f32.add + get_local 3 + f32.add) + (func (;1;) (type 1) (param f64 f64 f64 f64) (result f64) + get_local 0 + get_local 1 + f64.add + get_local 2 + f64.add + get_local 3 + f64.add) + (export \"f32.no_reassociate_add\" (func 0)) + (export \"f64.no_reassociate_add\" (func 1))) + "; + 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_22(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 340 +fn c139_l340_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c139_l340_action_invoke"); + let result = instance.call("f32.no_reassociate_add", &[Value::F32((-24154321000000.0f32).to_bits()), Value::F32((26125812000.0f32).to_bits()), Value::F32((-238608080000000.0f32).to_bits()), Value::F32((-2478953500000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-265215220000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 341 +fn c140_l341_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c140_l341_action_invoke"); + let result = instance.call("f32.no_reassociate_add", &[Value::F32((0.0036181053f32).to_bits()), Value::F32((-0.00985944f32).to_bits()), Value::F32((0.063375376f32).to_bits()), Value::F32((-0.011150199f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.04598384f32).to_bits())))); + result.map(|_| ()) +} + +// Line 342 +fn c141_l342_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c141_l342_action_invoke"); + let result = instance.call("f32.no_reassociate_add", &[Value::F32((-34206968000.0f32).to_bits()), Value::F32((-3770877200000.0f32).to_bits()), Value::F32((30868425000000.0f32).to_bits()), Value::F32((421132080000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((27484470000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 343 +fn c142_l343_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c142_l343_action_invoke"); + let result = instance.call("f32.no_reassociate_add", &[Value::F32((153506400000000.0f32).to_bits()), Value::F32((925114700000000.0f32).to_bits()), Value::F32((-36021854000.0f32).to_bits()), Value::F32((2450846000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((3529431000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 344 +fn c143_l344_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c143_l344_action_invoke"); + let result = instance.call("f32.no_reassociate_add", &[Value::F32((470600300000000000000000000000000.0f32).to_bits()), Value::F32((-396552040000000000000000000000000.0f32).to_bits()), Value::F32((48066940000000000000000000000000.0f32).to_bits()), Value::F32((-35644073000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((122079560000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 345 +fn c144_l345_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c144_l345_action_invoke"); + let result = instance.call("f64.no_reassociate_add", &[Value::F64((-20704652927717020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((1594689704376369700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((451106636559416130000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-1374333509186863300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-921652887575998600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 346 +fn c145_l346_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c145_l346_action_invoke"); + let result = instance.call("f64.no_reassociate_add", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003485747658213531f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000031210957391311754f64).to_bits()), Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000683008546431621f64).to_bits()), Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002617177347131095f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022324206697150536f64).to_bits())))); + result.map(|_| ()) +} + +// Line 347 +fn c146_l347_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c146_l347_action_invoke"); + let result = instance.call("f64.no_reassociate_add", &[Value::F64((-5412584921122726300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((597603656170379500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-355830077793396300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((373627259957625440000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-5768414998318146000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 348 +fn c147_l348_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c147_l348_action_invoke"); + let result = instance.call("f64.no_reassociate_add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006469047714189599f64).to_bits()), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000064286584974746f64).to_bits()), Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000021277698072285604f64).to_bits()), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000008768287273189493f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000006640517465960996f64).to_bits())))); + result.map(|_| ()) +} + +// Line 349 +fn c148_l349_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c148_l349_action_invoke"); + let result = instance.call("f64.no_reassociate_add", &[Value::F64((-16422137086414828000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-88032137939790710000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((449957059782857850000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-114091267166274390000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((319443655442136560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 353 + +#[test] +fn test_module_22() { + let mut instance = create_module_22(); + // We group the calls together + start_module_22(&mut instance); + c139_l340_action_invoke(&mut instance); + c140_l341_action_invoke(&mut instance); + c141_l342_action_invoke(&mut instance); + c142_l343_action_invoke(&mut instance); + c143_l344_action_invoke(&mut instance); + c144_l345_action_invoke(&mut instance); + c145_l346_action_invoke(&mut instance); + c146_l347_action_invoke(&mut instance); + c147_l348_action_invoke(&mut instance); + c148_l349_action_invoke(&mut instance); +} +fn create_module_23() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32 f32 f32) (result f32))) + (type (;1;) (func (param f64 f64 f64 f64) (result f64))) + (func (;0;) (type 0) (param f32 f32 f32 f32) (result f32) + get_local 0 + get_local 1 + f32.mul + get_local 2 + f32.mul + get_local 3 + f32.mul) + (func (;1;) (type 1) (param f64 f64 f64 f64) (result f64) + get_local 0 + get_local 1 + f64.mul + get_local 2 + f64.mul + get_local 3 + f64.mul) + (export \"f32.no_reassociate_mul\" (func 0)) + (export \"f64.no_reassociate_mul\" (func 1))) + "; + 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_23(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 360 +fn c150_l360_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c150_l360_action_invoke"); + let result = instance.call("f32.no_reassociate_mul", &[Value::F32((0.00000000000000000000000000000000001904515f32).to_bits()), Value::F32((0.00000000022548861f32).to_bits()), Value::F32((-6964322000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000026902832f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000000000000000078764173f32).to_bits())))); + result.map(|_| ()) +} + +// Line 361 +fn c151_l361_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c151_l361_action_invoke"); + let result = instance.call("f32.no_reassociate_mul", &[Value::F32((0.000000000000000018733125f32).to_bits()), Value::F32((-7565904000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000030807684f32).to_bits()), Value::F32((-1592759200000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0069547286f32).to_bits())))); + result.map(|_| ()) +} + +// Line 362 +fn c152_l362_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c152_l362_action_invoke"); + let result = instance.call("f32.no_reassociate_mul", &[Value::F32((0.0000000000000050355575f32).to_bits()), Value::F32((-56466884000000000.0f32).to_bits()), Value::F32((-0.0000000000011740512f32).to_bits()), Value::F32((84984730000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((28370654000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 363 +fn c153_l363_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c153_l363_action_invoke"); + let result = instance.call("f32.no_reassociate_mul", &[Value::F32((0.000000000000000000000000000000046394946f32).to_bits()), Value::F32((254449360000000000000000.0f32).to_bits()), Value::F32((-72460980000000000.0f32).to_bits()), Value::F32((-962511040000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((823345100000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 364 +fn c154_l364_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c154_l364_action_invoke"); + let result = instance.call("f32.no_reassociate_mul", &[Value::F32((-0.0000000000000000000000000000019420536f32).to_bits()), Value::F32((0.0000000000000023200355f32).to_bits()), Value::F32((-9.772748f32).to_bits()), Value::F32((864066000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000035113616f32).to_bits())))); + result.map(|_| ()) +} + +// Line 365 +fn c155_l365_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c155_l365_action_invoke"); + let result = instance.call("f64.no_reassociate_mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003109868654414946f64).to_bits()), Value::F64((-20713190487745434000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007162612845524978f64).to_bits()), Value::F64((-88478253295969090000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((40822261813278614000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 366 +fn c156_l366_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c156_l366_action_invoke"); + let result = instance.call("f64.no_reassociate_mul", &[Value::F64((60442716412956810000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006700545015107397f64).to_bits()), Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000031469664275798185f64).to_bits()), Value::F64((-6401677295640561500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008159057447560471f64).to_bits())))); + result.map(|_| ()) +} + +// Line 367 +fn c157_l367_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c157_l367_action_invoke"); + let result = instance.call("f64.no_reassociate_mul", &[Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002216807720454268f64).to_bits()), Value::F64((-1802234186536721600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007500283778521931f64).to_bits()), Value::F64((-414412152433956900000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001241793627299937f64).to_bits())))); + result.map(|_| ()) +} + +// Line 368 +fn c158_l368_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c158_l368_action_invoke"); + let result = instance.call("f64.no_reassociate_mul", &[Value::F64((24318065966298720000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006508014075793436f64).to_bits()), Value::F64((17596421287233897000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.0000001416141401305358f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-3943741918531223000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 369 +fn c159_l369_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c159_l369_action_invoke"); + let result = instance.call("f64.no_reassociate_mul", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000003849767156964772f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000070008754943224875f64).to_bits()), Value::F64((-2536887825218386500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006101114518858449f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004171548126376117f64).to_bits())))); + result.map(|_| ()) +} + +// Line 373 + +#[test] +fn test_module_23() { + let mut instance = create_module_23(); + // We group the calls together + start_module_23(&mut instance); + c150_l360_action_invoke(&mut instance); + c151_l361_action_invoke(&mut instance); + c152_l362_action_invoke(&mut instance); + c153_l363_action_invoke(&mut instance); + c154_l364_action_invoke(&mut instance); + c155_l365_action_invoke(&mut instance); + c156_l366_action_invoke(&mut instance); + c157_l367_action_invoke(&mut instance); + c158_l368_action_invoke(&mut instance); + c159_l369_action_invoke(&mut instance); +} +fn create_module_24() -> Box { + let module_str = "(module + (type (;0;) (func (param f32) (result f32))) + (type (;1;) (func (param f64) (result f64))) + (func (;0;) (type 0) (param f32) (result f32) + get_local 0 + f32.const 0x0p+0 (;=0;) + f32.div) + (func (;1;) (type 1) (param f64) (result f64) + get_local 0 + f64.const 0x0p+0 (;=0;) + f64.div) + (export \"f32.no_fold_div_0\" (func 0)) + (export \"f64.no_fold_div_0\" (func 1))) + "; + 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_24(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 380 +fn c161_l380_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c161_l380_action_invoke"); + let result = instance.call("f32.no_fold_div_0", &[Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 381 +fn c162_l381_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c162_l381_action_invoke"); + let result = instance.call("f32.no_fold_div_0", &[Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 382 +fn c163_l382_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c163_l382_action_invoke"); + let result = instance.call("f32.no_fold_div_0", &[Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 383 +fn c164_l383_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c164_l383_action_invoke"); + let result = instance.call("f32.no_fold_div_0", &[Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 384 +fn c165_l384_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c165_l384_assert_return_canonical_nan"); + let result = instance.call("f32.no_fold_div_0", &[Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c165_l384_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 385 +fn c166_l385_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c166_l385_assert_return_canonical_nan"); + let result = instance.call("f32.no_fold_div_0", &[Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c166_l385_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 386 +fn c167_l386_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c167_l386_assert_return_arithmetic_nan"); + let result = instance.call("f32.no_fold_div_0", &[Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c167_l386_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 387 +fn c168_l387_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c168_l387_assert_return_canonical_nan"); + let result = instance.call("f32.no_fold_div_0", &[Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c168_l387_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 388 +fn c169_l388_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c169_l388_action_invoke"); + let result = instance.call("f64.no_fold_div_0", &[Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 389 +fn c170_l389_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c170_l389_action_invoke"); + let result = instance.call("f64.no_fold_div_0", &[Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 390 +fn c171_l390_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c171_l390_action_invoke"); + let result = instance.call("f64.no_fold_div_0", &[Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 391 +fn c172_l391_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c172_l391_action_invoke"); + let result = instance.call("f64.no_fold_div_0", &[Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 392 +fn c173_l392_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c173_l392_assert_return_canonical_nan"); + let result = instance.call("f64.no_fold_div_0", &[Value::F64((0.0f64).to_bits())]).unwrap().expect("Missing result in c173_l392_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 393 +fn c174_l393_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c174_l393_assert_return_canonical_nan"); + let result = instance.call("f64.no_fold_div_0", &[Value::F64((-0.0f64).to_bits())]).unwrap().expect("Missing result in c174_l393_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 394 +fn c175_l394_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c175_l394_assert_return_canonical_nan"); + let result = instance.call("f64.no_fold_div_0", &[Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c175_l394_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 395 +fn c176_l395_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c176_l395_assert_return_arithmetic_nan"); + let result = instance.call("f64.no_fold_div_0", &[Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c176_l395_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 399 + +#[test] +fn test_module_24() { + let mut instance = create_module_24(); + // We group the calls together + start_module_24(&mut instance); + c161_l380_action_invoke(&mut instance); + c162_l381_action_invoke(&mut instance); + c163_l382_action_invoke(&mut instance); + c164_l383_action_invoke(&mut instance); + c165_l384_assert_return_canonical_nan(&mut instance); + c166_l385_assert_return_canonical_nan(&mut instance); + c167_l386_assert_return_arithmetic_nan(&mut instance); + c168_l387_assert_return_canonical_nan(&mut instance); + c169_l388_action_invoke(&mut instance); + c170_l389_action_invoke(&mut instance); + c171_l390_action_invoke(&mut instance); + c172_l391_action_invoke(&mut instance); + c173_l392_assert_return_canonical_nan(&mut instance); + c174_l393_assert_return_canonical_nan(&mut instance); + c175_l394_assert_return_canonical_nan(&mut instance); + c176_l395_assert_return_arithmetic_nan(&mut instance); +} +fn create_module_25() -> Box { + let module_str = "(module + (type (;0;) (func (param f32) (result f32))) + (type (;1;) (func (param f64) (result f64))) + (func (;0;) (type 0) (param f32) (result f32) + get_local 0 + f32.const -0x0p+0 (;=-0;) + f32.div) + (func (;1;) (type 1) (param f64) (result f64) + get_local 0 + f64.const -0x0p+0 (;=-0;) + f64.div) + (export \"f32.no_fold_div_neg0\" (func 0)) + (export \"f64.no_fold_div_neg0\" (func 1))) + "; + 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_25(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 406 +fn c178_l406_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c178_l406_action_invoke"); + let result = instance.call("f32.no_fold_div_neg0", &[Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 407 +fn c179_l407_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c179_l407_action_invoke"); + let result = instance.call("f32.no_fold_div_neg0", &[Value::F32((-1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 408 +fn c180_l408_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c180_l408_action_invoke"); + let result = instance.call("f32.no_fold_div_neg0", &[Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 409 +fn c181_l409_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c181_l409_action_invoke"); + let result = instance.call("f32.no_fold_div_neg0", &[Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 410 +fn c182_l410_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c182_l410_assert_return_canonical_nan"); + let result = instance.call("f32.no_fold_div_neg0", &[Value::F32((0.0f32).to_bits())]).unwrap().expect("Missing result in c182_l410_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 411 +fn c183_l411_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c183_l411_assert_return_canonical_nan"); + let result = instance.call("f32.no_fold_div_neg0", &[Value::F32((-0.0f32).to_bits())]).unwrap().expect("Missing result in c183_l411_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 412 +fn c184_l412_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c184_l412_assert_return_arithmetic_nan"); + let result = instance.call("f32.no_fold_div_neg0", &[Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c184_l412_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 413 +fn c185_l413_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c185_l413_assert_return_canonical_nan"); + let result = instance.call("f32.no_fold_div_neg0", &[Value::F32(f32::from_bits(2143289344) as u32)]).unwrap().expect("Missing result in c185_l413_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 414 +fn c186_l414_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c186_l414_action_invoke"); + let result = instance.call("f64.no_fold_div_neg0", &[Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 415 +fn c187_l415_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c187_l415_action_invoke"); + let result = instance.call("f64.no_fold_div_neg0", &[Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 416 +fn c188_l416_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c188_l416_action_invoke"); + let result = instance.call("f64.no_fold_div_neg0", &[Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 417 +fn c189_l417_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c189_l417_action_invoke"); + let result = instance.call("f64.no_fold_div_neg0", &[Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 418 +fn c190_l418_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c190_l418_assert_return_canonical_nan"); + let result = instance.call("f64.no_fold_div_neg0", &[Value::F64((0.0f64).to_bits())]).unwrap().expect("Missing result in c190_l418_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 419 +fn c191_l419_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c191_l419_assert_return_canonical_nan"); + let result = instance.call("f64.no_fold_div_neg0", &[Value::F64((-0.0f64).to_bits())]).unwrap().expect("Missing result in c191_l419_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 420 +fn c192_l420_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c192_l420_assert_return_canonical_nan"); + let result = instance.call("f64.no_fold_div_neg0", &[Value::F64(f64::from_bits(9221120237041090560) as u64)]).unwrap().expect("Missing result in c192_l420_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 421 +fn c193_l421_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c193_l421_assert_return_arithmetic_nan"); + let result = instance.call("f64.no_fold_div_neg0", &[Value::F64(f64::from_bits(9219994337134247936) as u64)]).unwrap().expect("Missing result in c193_l421_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 425 + +#[test] +fn test_module_25() { + let mut instance = create_module_25(); + // We group the calls together + start_module_25(&mut instance); + c178_l406_action_invoke(&mut instance); + c179_l407_action_invoke(&mut instance); + c180_l408_action_invoke(&mut instance); + c181_l409_action_invoke(&mut instance); + c182_l410_assert_return_canonical_nan(&mut instance); + c183_l411_assert_return_canonical_nan(&mut instance); + c184_l412_assert_return_arithmetic_nan(&mut instance); + c185_l413_assert_return_canonical_nan(&mut instance); + c186_l414_action_invoke(&mut instance); + c187_l415_action_invoke(&mut instance); + c188_l416_action_invoke(&mut instance); + c189_l417_action_invoke(&mut instance); + c190_l418_assert_return_canonical_nan(&mut instance); + c191_l419_assert_return_canonical_nan(&mut instance); + c192_l420_assert_return_canonical_nan(&mut instance); + c193_l421_assert_return_arithmetic_nan(&mut instance); +} +fn create_module_26() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32) (result f32))) + (type (;1;) (func (param f64 f64) (result f64))) + (func (;0;) (type 0) (param f32 f32) (result f32) + get_local 0 + get_local 0 + f32.mul + get_local 1 + get_local 1 + f32.mul + f32.add + f32.sqrt) + (func (;1;) (type 1) (param f64 f64) (result f64) + get_local 0 + get_local 0 + f64.mul + get_local 1 + get_local 1 + f64.mul + f64.add + f64.sqrt) + (export \"f32.no_fold_to_hypot\" (func 0)) + (export \"f64.no_fold_to_hypot\" (func 1))) + "; + 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_26(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 434 +fn c195_l434_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c195_l434_action_invoke"); + let result = instance.call("f32.no_fold_to_hypot", &[Value::F32((0.00000000000000000000000072854914f32).to_bits()), Value::F32((0.0000000000000000000042365796f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000042366535f32).to_bits())))); + result.map(|_| ()) +} + +// Line 435 +fn c196_l435_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c196_l435_action_invoke"); + let result = instance.call("f32.no_fold_to_hypot", &[Value::F32((-0.0000000000000000000007470285f32).to_bits()), Value::F32((-0.000000000000000000000000000000007453745f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000007468044f32).to_bits())))); + result.map(|_| ()) +} + +// Line 436 +fn c197_l436_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c197_l436_action_invoke"); + let result = instance.call("f32.no_fold_to_hypot", &[Value::F32((-0.0000000000000000000000000000000000770895f32).to_bits()), Value::F32((-0.0000000000000000000032627214f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000032627695f32).to_bits())))); + result.map(|_| ()) +} + +// Line 437 +fn c198_l437_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c198_l437_action_invoke"); + let result = instance.call("f32.no_fold_to_hypot", &[Value::F32((-35.42818f32).to_bits()), Value::F32((174209.48f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((174209.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 438 +fn c199_l438_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c199_l438_action_invoke"); + let result = instance.call("f32.no_fold_to_hypot", &[Value::F32((0.000000000000000000000020628143f32).to_bits()), Value::F32((-0.00000000000000000000046344753f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000463032f32).to_bits())))); + result.map(|_| ()) +} + +// Line 439 +fn c200_l439_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c200_l439_action_invoke"); + let result = instance.call("f64.no_fold_to_hypot", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003863640258986321f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000019133014752624014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000019120893753235554f64).to_bits())))); + result.map(|_| ()) +} + +// Line 440 +fn c201_l440_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c201_l440_action_invoke"); + let result = instance.call("f64.no_fold_to_hypot", &[Value::F64((138561238950329770000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-2828038515930043000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((2828038519324483400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 441 +fn c202_l441_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c202_l441_action_invoke"); + let result = instance.call("f64.no_fold_to_hypot", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006502729096641792f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004544399933151275f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006668276248455232f64).to_bits())))); + result.map(|_| ()) +} + +// Line 442 +fn c203_l442_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c203_l442_action_invoke"); + let result = instance.call("f64.no_fold_to_hypot", &[Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022340232024202604f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003435929714143315f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022340232023799234f64).to_bits())))); + result.map(|_| ()) +} + +// Line 443 +fn c204_l443_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c204_l443_action_invoke"); + let result = instance.call("f64.no_fold_to_hypot", &[Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002797963998630554f64).to_bits()), Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001906867996862016f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000019068679968620105f64).to_bits())))); + result.map(|_| ()) +} + +// Line 447 + +#[test] +fn test_module_26() { + let mut instance = create_module_26(); + // We group the calls together + start_module_26(&mut instance); + c195_l434_action_invoke(&mut instance); + c196_l435_action_invoke(&mut instance); + c197_l436_action_invoke(&mut instance); + c198_l437_action_invoke(&mut instance); + c199_l438_action_invoke(&mut instance); + c200_l439_action_invoke(&mut instance); + c201_l440_action_invoke(&mut instance); + c202_l441_action_invoke(&mut instance); + c203_l442_action_invoke(&mut instance); + c204_l443_action_invoke(&mut instance); +} +fn create_module_27() -> Box { + let module_str = "(module + (type (;0;) (func (param f32) (result f32))) + (func (;0;) (type 0) (param f32) (result f32) + f32.const 0x1p+0 (;=1;) + get_local 0 + f32.div) + (export \"f32.no_approximate_reciprocal\" (func 0))) + "; + 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_27(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 452 +fn c206_l452_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c206_l452_action_invoke"); + let result = instance.call("f32.no_approximate_reciprocal", &[Value::F32((-0.0011329757f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-882.6315f32).to_bits())))); + result.map(|_| ()) +} + +// Line 453 +fn c207_l453_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c207_l453_action_invoke"); + let result = instance.call("f32.no_approximate_reciprocal", &[Value::F32((323753010000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000003088774f32).to_bits())))); + result.map(|_| ()) +} + +// Line 454 +fn c208_l454_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c208_l454_action_invoke"); + let result = instance.call("f32.no_approximate_reciprocal", &[Value::F32((-0.0000000000000000000000000001272599f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-7857934600000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 455 +fn c209_l455_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c209_l455_action_invoke"); + let result = instance.call("f32.no_approximate_reciprocal", &[Value::F32((103020680000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000009706789f32).to_bits())))); + result.map(|_| ()) +} + +// Line 456 +fn c210_l456_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c210_l456_action_invoke"); + let result = instance.call("f32.no_approximate_reciprocal", &[Value::F32((-0.00000000000000000000000028443763f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-3515709300000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 460 + +#[test] +fn test_module_27() { + let mut instance = create_module_27(); + // We group the calls together + start_module_27(&mut instance); + c206_l452_action_invoke(&mut instance); + c207_l453_action_invoke(&mut instance); + c208_l454_action_invoke(&mut instance); + c209_l455_action_invoke(&mut instance); + c210_l456_action_invoke(&mut instance); +} +fn create_module_28() -> Box { + let module_str = "(module + (type (;0;) (func (param f32) (result f32))) + (type (;1;) (func (param f64) (result f64))) + (func (;0;) (type 0) (param f32) (result f32) + f32.const 0x1p+0 (;=1;) + get_local 0 + f32.sqrt + f32.div) + (func (;1;) (type 1) (param f64) (result f64) + f64.const 0x1p+0 (;=1;) + get_local 0 + f64.sqrt + f64.div) + (export \"f32.no_approximate_reciprocal_sqrt\" (func 0)) + (export \"f64.no_fuse_reciprocal_sqrt\" (func 1))) + "; + 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_28(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 467 +fn c212_l467_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c212_l467_action_invoke"); + let result = instance.call("f32.no_approximate_reciprocal_sqrt", &[Value::F32((0.00000000000016117865f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((2490842.5f32).to_bits())))); + result.map(|_| ()) +} + +// Line 468 +fn c213_l468_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c213_l468_action_invoke"); + let result = instance.call("f32.no_approximate_reciprocal_sqrt", &[Value::F32((0.0074491366f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((11.58636f32).to_bits())))); + result.map(|_| ()) +} + +// Line 469 +fn c214_l469_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c214_l469_action_invoke"); + let result = instance.call("f32.no_approximate_reciprocal_sqrt", &[Value::F32((0.00000000000000000002339817f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((6537460000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 470 +fn c215_l470_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c215_l470_action_invoke"); + let result = instance.call("f32.no_approximate_reciprocal_sqrt", &[Value::F32((0.00000000000011123504f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((2998328.3f32).to_bits())))); + result.map(|_| ()) +} + +// Line 471 +fn c216_l471_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c216_l471_action_invoke"); + let result = instance.call("f32.no_approximate_reciprocal_sqrt", &[Value::F32((0.000000000000000000000000017653063f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((7526446300000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 473 +fn c217_l473_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c217_l473_action_invoke"); + let result = instance.call("f64.no_fuse_reciprocal_sqrt", &[Value::F64((4472459252766337000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014952947335898096f64).to_bits())))); + result.map(|_| ()) +} + +// Line 474 +fn c218_l474_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c218_l474_action_invoke"); + let result = instance.call("f64.no_fuse_reciprocal_sqrt", &[Value::F64((4752392260007119000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000014505872638954843f64).to_bits())))); + result.map(|_| ()) +} + +// Line 475 +fn c219_l475_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c219_l475_action_invoke"); + let result = instance.call("f64.no_fuse_reciprocal_sqrt", &[Value::F64((29014415885392436000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000018564920084793608f64).to_bits())))); + result.map(|_| ()) +} + +// Line 476 +fn c220_l476_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c220_l476_action_invoke"); + let result = instance.call("f64.no_fuse_reciprocal_sqrt", &[Value::F64((1396612507697477800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000026758516751072132f64).to_bits())))); + result.map(|_| ()) +} + +// Line 477 +fn c221_l477_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c221_l477_action_invoke"); + let result = instance.call("f64.no_fuse_reciprocal_sqrt", &[Value::F64((151596415440704430000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000008121860649480894f64).to_bits())))); + result.map(|_| ()) +} + +// Line 481 + +#[test] +fn test_module_28() { + let mut instance = create_module_28(); + // We group the calls together + start_module_28(&mut instance); + c212_l467_action_invoke(&mut instance); + c213_l468_action_invoke(&mut instance); + c214_l469_action_invoke(&mut instance); + c215_l470_action_invoke(&mut instance); + c216_l471_action_invoke(&mut instance); + c217_l473_action_invoke(&mut instance); + c218_l474_action_invoke(&mut instance); + c219_l475_action_invoke(&mut instance); + c220_l476_action_invoke(&mut instance); + c221_l477_action_invoke(&mut instance); +} +fn create_module_29() -> Box { + let module_str = "(module + (type (;0;) (func (param f32) (result f32))) + (func (;0;) (type 0) (param f32) (result f32) + f32.const 0x1p+0 (;=1;) + get_local 0 + f32.div + f32.sqrt) + (export \"f32.no_approximate_sqrt_reciprocal\" (func 0))) + "; + 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_29(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 486 +fn c223_l486_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c223_l486_action_invoke"); + let result = instance.call("f32.no_approximate_sqrt_reciprocal", &[Value::F32((1895057100000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.00000000072642176f32).to_bits())))); + result.map(|_| ()) +} + +// Line 487 +fn c224_l487_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c224_l487_action_invoke"); + let result = instance.call("f32.no_approximate_sqrt_reciprocal", &[Value::F32((0.002565894f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((19.741522f32).to_bits())))); + result.map(|_| ()) +} + +// Line 488 +fn c225_l488_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c225_l488_action_invoke"); + let result = instance.call("f32.no_approximate_sqrt_reciprocal", &[Value::F32((632654500000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000039757284f32).to_bits())))); + result.map(|_| ()) +} + +// Line 489 +fn c226_l489_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c226_l489_action_invoke"); + let result = instance.call("f32.no_approximate_sqrt_reciprocal", &[Value::F32((14153.539f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.008405576f32).to_bits())))); + result.map(|_| ()) +} + +// Line 490 +fn c227_l490_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c227_l490_action_invoke"); + let result = instance.call("f32.no_approximate_sqrt_reciprocal", &[Value::F32((26173730000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.00000000000000019546418f32).to_bits())))); + result.map(|_| ()) +} + +// Line 494 + +#[test] +fn test_module_29() { + let mut instance = create_module_29(); + // We group the calls together + start_module_29(&mut instance); + c223_l486_action_invoke(&mut instance); + c224_l487_action_invoke(&mut instance); + c225_l488_action_invoke(&mut instance); + c226_l489_action_invoke(&mut instance); + c227_l490_action_invoke(&mut instance); +} +fn create_module_30() -> Box { + let module_str = "(module + (type (;0;) (func (param i32) (result i32))) + (type (;1;) (func (param i64) (result i64))) + (func (;0;) (type 0) (param i32) (result i32) + get_local 0 + f32.convert_s/i32 + i32.trunc_s/f32) + (func (;1;) (type 0) (param i32) (result i32) + get_local 0 + f32.convert_u/i32 + i32.trunc_u/f32) + (func (;2;) (type 1) (param i64) (result i64) + get_local 0 + f64.convert_s/i64 + i64.trunc_s/f64) + (func (;3;) (type 1) (param i64) (result i64) + get_local 0 + f64.convert_u/i64 + i64.trunc_u/f64) + (export \"i32.no_fold_f32_s\" (func 0)) + (export \"i32.no_fold_f32_u\" (func 1)) + (export \"i64.no_fold_f64_s\" (func 2)) + (export \"i64.no_fold_f64_u\" (func 3))) + "; + 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_30(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 505 +fn c229_l505_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c229_l505_action_invoke"); + let result = instance.call("i32.no_fold_f32_s", &[Value::I32(16777216 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(16777216 as i32)))); + result.map(|_| ()) +} + +// Line 506 +fn c230_l506_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c230_l506_action_invoke"); + let result = instance.call("i32.no_fold_f32_s", &[Value::I32(16777217 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(16777216 as i32)))); + result.map(|_| ()) +} + +// Line 507 +fn c231_l507_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c231_l507_action_invoke"); + let result = instance.call("i32.no_fold_f32_s", &[Value::I32(-268435440 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-268435440 as i32)))); + result.map(|_| ()) +} + +// Line 509 +fn c232_l509_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c232_l509_action_invoke"); + let result = instance.call("i32.no_fold_f32_u", &[Value::I32(16777216 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(16777216 as i32)))); + result.map(|_| ()) +} + +// Line 510 +fn c233_l510_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c233_l510_action_invoke"); + let result = instance.call("i32.no_fold_f32_u", &[Value::I32(16777217 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(16777216 as i32)))); + result.map(|_| ()) +} + +// Line 511 +fn c234_l511_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c234_l511_action_invoke"); + let result = instance.call("i32.no_fold_f32_u", &[Value::I32(-268435440 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-268435456 as i32)))); + result.map(|_| ()) +} + +// Line 513 +fn c235_l513_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c235_l513_action_invoke"); + let result = instance.call("i64.no_fold_f64_s", &[Value::I64(9007199254740992 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(9007199254740992 as i64)))); + result.map(|_| ()) +} + +// Line 514 +fn c236_l514_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c236_l514_action_invoke"); + let result = instance.call("i64.no_fold_f64_s", &[Value::I64(9007199254740993 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(9007199254740992 as i64)))); + result.map(|_| ()) +} + +// Line 515 +fn c237_l515_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c237_l515_action_invoke"); + let result = instance.call("i64.no_fold_f64_s", &[Value::I64(-1152921504606845952 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-1152921504606845952 as i64)))); + result.map(|_| ()) +} + +// Line 517 +fn c238_l517_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c238_l517_action_invoke"); + let result = instance.call("i64.no_fold_f64_u", &[Value::I64(9007199254740992 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(9007199254740992 as i64)))); + result.map(|_| ()) +} + +// Line 518 +fn c239_l518_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c239_l518_action_invoke"); + let result = instance.call("i64.no_fold_f64_u", &[Value::I64(9007199254740993 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(9007199254740992 as i64)))); + result.map(|_| ()) +} + +// Line 519 +fn c240_l519_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c240_l519_action_invoke"); + let result = instance.call("i64.no_fold_f64_u", &[Value::I64(-1152921504606845952 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-1152921504606846976 as i64)))); + result.map(|_| ()) +} + +// Line 523 + +#[test] +fn test_module_30() { + let mut instance = create_module_30(); + // We group the calls together + start_module_30(&mut instance); + c229_l505_action_invoke(&mut instance); + c230_l506_action_invoke(&mut instance); + c231_l507_action_invoke(&mut instance); + c232_l509_action_invoke(&mut instance); + c233_l510_action_invoke(&mut instance); + c234_l511_action_invoke(&mut instance); + c235_l513_action_invoke(&mut instance); + c236_l514_action_invoke(&mut instance); + c237_l515_action_invoke(&mut instance); + c238_l517_action_invoke(&mut instance); + c239_l518_action_invoke(&mut instance); + c240_l519_action_invoke(&mut instance); +} +fn create_module_31() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32) (result f32))) + (type (;1;) (func (param f64 f64) (result f64))) + (func (;0;) (type 0) (param f32 f32) (result f32) + get_local 0 + get_local 1 + f32.add + get_local 1 + f32.sub) + (func (;1;) (type 1) (param f64 f64) (result f64) + get_local 0 + get_local 1 + f64.add + get_local 1 + f64.sub) + (export \"f32.no_fold_add_sub\" (func 0)) + (export \"f64.no_fold_add_sub\" (func 1))) + "; + 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_31(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 530 +fn c242_l530_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c242_l530_action_invoke"); + let result = instance.call("f32.no_fold_add_sub", &[Value::F32((0.000000000000012138282f32).to_bits()), Value::F32((-0.000000020946384f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000012434498f32).to_bits())))); + result.map(|_| ()) +} + +// Line 531 +fn c243_l531_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c243_l531_action_invoke"); + let result = instance.call("f32.no_fold_add_sub", &[Value::F32((-0.00000019768197f32).to_bits()), Value::F32((0.0000037154566f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.00000019768208f32).to_bits())))); + result.map(|_| ()) +} + +// Line 532 +fn c244_l532_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c244_l532_action_invoke"); + let result = instance.call("f32.no_fold_add_sub", &[Value::F32((-9596213000000000000000000.0f32).to_bits()), Value::F32((-3538041400000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-9671407000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 533 +fn c245_l533_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c245_l533_action_invoke"); + let result = instance.call("f32.no_fold_add_sub", &[Value::F32((0.000000000000000000000005054346f32).to_bits()), Value::F32((0.000000000000000024572656f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000000049630837f32).to_bits())))); + result.map(|_| ()) +} + +// Line 534 +fn c246_l534_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c246_l534_action_invoke"); + let result = instance.call("f32.no_fold_add_sub", &[Value::F32((-0.0000000000000000000000000000000033693147f32).to_bits()), Value::F32((-0.000000000000000000000000071014917f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000006162976f32).to_bits())))); + result.map(|_| ()) +} + +// Line 536 +fn c247_l536_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c247_l536_action_invoke"); + let result = instance.call("f64.no_fold_add_sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008445702651973109f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001110684389828854f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008445702651873978f64).to_bits())))); + result.map(|_| ()) +} + +// Line 537 +fn c248_l537_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c248_l537_action_invoke"); + let result = instance.call("f64.no_fold_add_sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008198798715927055f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004624035606110903f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008198798715897085f64).to_bits())))); + result.map(|_| ()) +} + +// Line 538 +fn c249_l538_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c249_l538_action_invoke"); + let result = instance.call("f64.no_fold_add_sub", &[Value::F64((-0.0000000013604511322066714f64).to_bits()), Value::F64((-0.1751431740707098f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0000000013604511406306585f64).to_bits())))); + result.map(|_| ()) +} + +// Line 539 +fn c250_l539_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c250_l539_action_invoke"); + let result = instance.call("f64.no_fold_add_sub", &[Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003944335437865966f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001663809741322667f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000039443355500325104f64).to_bits())))); + result.map(|_| ()) +} + +// Line 540 +fn c251_l540_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c251_l540_action_invoke"); + let result = instance.call("f64.no_fold_add_sub", &[Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005078309818866f64).to_bits()), Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010790431644461104f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000507831047937567f64).to_bits())))); + result.map(|_| ()) +} + +// Line 544 + +#[test] +fn test_module_31() { + let mut instance = create_module_31(); + // We group the calls together + start_module_31(&mut instance); + c242_l530_action_invoke(&mut instance); + c243_l531_action_invoke(&mut instance); + c244_l532_action_invoke(&mut instance); + c245_l533_action_invoke(&mut instance); + c246_l534_action_invoke(&mut instance); + c247_l536_action_invoke(&mut instance); + c248_l537_action_invoke(&mut instance); + c249_l538_action_invoke(&mut instance); + c250_l539_action_invoke(&mut instance); + c251_l540_action_invoke(&mut instance); +} +fn create_module_32() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32) (result f32))) + (type (;1;) (func (param f64 f64) (result f64))) + (func (;0;) (type 0) (param f32 f32) (result f32) + get_local 0 + get_local 1 + f32.sub + get_local 1 + f32.add) + (func (;1;) (type 1) (param f64 f64) (result f64) + get_local 0 + get_local 1 + f64.sub + get_local 1 + f64.add) + (export \"f32.no_fold_sub_add\" (func 0)) + (export \"f64.no_fold_sub_add\" (func 1))) + "; + 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_32(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 551 +fn c253_l551_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c253_l551_action_invoke"); + let result = instance.call("f32.no_fold_sub_add", &[Value::F32((-676.47437f32).to_bits()), Value::F32((403.0368f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-676.4744f32).to_bits())))); + result.map(|_| ()) +} + +// Line 552 +fn c254_l552_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c254_l552_action_invoke"); + let result = instance.call("f32.no_fold_sub_add", &[Value::F32((-0.0000000000000000000000000000000006305943f32).to_bits()), Value::F32((0.0000000000000000000000000000367186f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000000000000000000063194576f32).to_bits())))); + result.map(|_| ()) +} + +// Line 553 +fn c255_l553_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c255_l553_action_invoke"); + let result = instance.call("f32.no_fold_sub_add", &[Value::F32((83184800.0f32).to_bits()), Value::F32((46216217000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((83185660.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 554 +fn c256_l554_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c256_l554_action_invoke"); + let result = instance.call("f32.no_fold_sub_add", &[Value::F32((0.000000000002211957f32).to_bits()), Value::F32((-0.00000001043793f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0000000000022115643f32).to_bits())))); + result.map(|_| ()) +} + +// Line 555 +fn c257_l555_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c257_l555_action_invoke"); + let result = instance.call("f32.no_fold_sub_add", &[Value::F32((0.14944395f32).to_bits()), Value::F32((-27393.65f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.15039063f32).to_bits())))); + result.map(|_| ()) +} + +// Line 557 +fn c258_l557_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c258_l557_action_invoke"); + let result = instance.call("f64.no_fold_sub_add", &[Value::F64((90365982617946240000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-958186427535552000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((90365982617946280000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 558 +fn c259_l558_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c259_l558_action_invoke"); + let result = instance.call("f64.no_fold_sub_add", &[Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044230403564658815f64).to_bits()), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000026713491049366576f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004423040356647721f64).to_bits())))); + result.map(|_| ()) +} + +// Line 559 +fn c260_l559_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c260_l559_action_invoke"); + let result = instance.call("f64.no_fold_sub_add", &[Value::F64((4095348452776429000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-4050190019576568700000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((4070815637249397500000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 560 +fn c261_l560_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c261_l560_action_invoke"); + let result = instance.call("f64.no_fold_sub_add", &[Value::F64((0.000000024008889207554433f64).to_bits()), Value::F64((-0.00017253797929188484f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000002400888920756506f64).to_bits())))); + result.map(|_| ()) +} + +// Line 561 +fn c262_l561_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c262_l561_action_invoke"); + let result = instance.call("f64.no_fold_sub_add", &[Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000043367542918305866f64).to_bits()), Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000039597706708227122f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004336754291830597f64).to_bits())))); + result.map(|_| ()) +} + +// Line 565 + +#[test] +fn test_module_32() { + let mut instance = create_module_32(); + // We group the calls together + start_module_32(&mut instance); + c253_l551_action_invoke(&mut instance); + c254_l552_action_invoke(&mut instance); + c255_l553_action_invoke(&mut instance); + c256_l554_action_invoke(&mut instance); + c257_l555_action_invoke(&mut instance); + c258_l557_action_invoke(&mut instance); + c259_l558_action_invoke(&mut instance); + c260_l559_action_invoke(&mut instance); + c261_l560_action_invoke(&mut instance); + c262_l561_action_invoke(&mut instance); +} +fn create_module_33() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32) (result f32))) + (type (;1;) (func (param f64 f64) (result f64))) + (func (;0;) (type 0) (param f32 f32) (result f32) + get_local 0 + get_local 1 + f32.mul + get_local 1 + f32.div) + (func (;1;) (type 1) (param f64 f64) (result f64) + get_local 0 + get_local 1 + f64.mul + get_local 1 + f64.div) + (export \"f32.no_fold_mul_div\" (func 0)) + (export \"f64.no_fold_mul_div\" (func 1))) + "; + 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_33(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 572 +fn c264_l572_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c264_l572_action_invoke"); + let result = instance.call("f32.no_fold_mul_div", &[Value::F32((-32476715000000000.0f32).to_bits()), Value::F32((0.000000000000010121375f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-32476713000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 573 +fn c265_l573_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c265_l573_action_invoke"); + let result = instance.call("f32.no_fold_mul_div", &[Value::F32((-0.000000015561163f32).to_bits()), Value::F32((0.000000000000000000000000000000015799828f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000015561145f32).to_bits())))); + result.map(|_| ()) +} + +// Line 574 +fn c266_l574_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c266_l574_action_invoke"); + let result = instance.call("f32.no_fold_mul_div", &[Value::F32((-0.00000000000000676311f32).to_bits()), Value::F32((-441324000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0000000000000067631096f32).to_bits())))); + result.map(|_| ()) +} + +// Line 575 +fn c267_l575_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c267_l575_action_invoke"); + let result = instance.call("f32.no_fold_mul_div", &[Value::F32((7505613700000000.0f32).to_bits()), Value::F32((-2160384100000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((7505613000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 576 +fn c268_l576_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c268_l576_action_invoke"); + let result = instance.call("f32.no_fold_mul_div", &[Value::F32((-0.0000000000000000000000000002362576f32).to_bits()), Value::F32((-0.000000000010808759f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000000000000023625765f32).to_bits())))); + result.map(|_| ()) +} + +// Line 578 +fn c269_l578_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c269_l578_action_invoke"); + let result = instance.call("f64.no_fold_mul_div", &[Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013532103713575586f64).to_bits()), Value::F64((-0.00000000000000000000000000000000000000000000000000000000000003347836467564916f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013532103713672434f64).to_bits())))); + result.map(|_| ()) +} + +// Line 579 +fn c270_l579_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c270_l579_action_invoke"); + let result = instance.call("f64.no_fold_mul_div", &[Value::F64((77662174313180845000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((195959155606939530000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((77662174313180850000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 580 +fn c271_l580_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c271_l580_action_invoke"); + let result = instance.call("f64.no_fold_mul_div", &[Value::F64((-718011781190294800000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009320036042623636f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-718011781190294750000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 581 +fn c272_l581_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c272_l581_action_invoke"); + let result = instance.call("f64.no_fold_mul_div", &[Value::F64((0.000000000000000000000000000000000000000000000000017260010724693063f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003568792428129926f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000001661286799244216f64).to_bits())))); + result.map(|_| ()) +} + +// Line 582 +fn c273_l582_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c273_l582_action_invoke"); + let result = instance.call("f64.no_fold_mul_div", &[Value::F64((-9145223045828962000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005562094034342845f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-9145223045828963000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 586 + +#[test] +fn test_module_33() { + let mut instance = create_module_33(); + // We group the calls together + start_module_33(&mut instance); + c264_l572_action_invoke(&mut instance); + c265_l573_action_invoke(&mut instance); + c266_l574_action_invoke(&mut instance); + c267_l575_action_invoke(&mut instance); + c268_l576_action_invoke(&mut instance); + c269_l578_action_invoke(&mut instance); + c270_l579_action_invoke(&mut instance); + c271_l580_action_invoke(&mut instance); + c272_l581_action_invoke(&mut instance); + c273_l582_action_invoke(&mut instance); +} +fn create_module_34() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32) (result f32))) + (type (;1;) (func (param f64 f64) (result f64))) + (func (;0;) (type 0) (param f32 f32) (result f32) + get_local 0 + get_local 1 + f32.div + get_local 1 + f32.mul) + (func (;1;) (type 1) (param f64 f64) (result f64) + get_local 0 + get_local 1 + f64.div + get_local 1 + f64.mul) + (export \"f32.no_fold_div_mul\" (func 0)) + (export \"f64.no_fold_div_mul\" (func 1))) + "; + 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_34(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 593 +fn c275_l593_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c275_l593_action_invoke"); + let result = instance.call("f32.no_fold_div_mul", &[Value::F32((-511517980000.0f32).to_bits()), Value::F32((986062200.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-511517950000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 594 +fn c276_l594_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c276_l594_action_invoke"); + let result = instance.call("f32.no_fold_div_mul", &[Value::F32((-0.00000000000000024944853f32).to_bits()), Value::F32((-0.0000041539834f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000024944856f32).to_bits())))); + result.map(|_| ()) +} + +// Line 595 +fn c277_l595_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c277_l595_action_invoke"); + let result = instance.call("f32.no_fold_div_mul", &[Value::F32((0.000000000000000000000000000000000000020827855f32).to_bits()), Value::F32((-235.19847f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000020828013f32).to_bits())))); + result.map(|_| ()) +} + +// Line 596 +fn c278_l596_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c278_l596_action_invoke"); + let result = instance.call("f32.no_fold_div_mul", &[Value::F32((-0.000000000000000000000062499487f32).to_bits()), Value::F32((-696312600000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000000006249919f32).to_bits())))); + result.map(|_| ()) +} + +// Line 597 +fn c279_l597_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c279_l597_action_invoke"); + let result = instance.call("f32.no_fold_div_mul", &[Value::F32((0.0000000000000000000000000000058353514f32).to_bits()), Value::F32((212781120.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000005835352f32).to_bits())))); + result.map(|_| ()) +} + +// Line 599 +fn c280_l599_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c280_l599_action_invoke"); + let result = instance.call("f64.no_fold_div_mul", &[Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000035984644259935362f64).to_bits()), Value::F64((-28812263298033320000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000035985034356565485f64).to_bits())))); + result.map(|_| ()) +} + +// Line 600 +fn c281_l600_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c281_l600_action_invoke"); + let result = instance.call("f64.no_fold_div_mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017486367047479447f64).to_bits()), Value::F64((0.00000000000000016508738454798636f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001748636704747945f64).to_bits())))); + result.map(|_| ()) +} + +// Line 601 +fn c282_l601_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c282_l601_action_invoke"); + let result = instance.call("f64.no_fold_div_mul", &[Value::F64((-0.00000000000000000000000000000000000000000003140341989542684f64).to_bits()), Value::F64((942829809081919600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000031403419895426836f64).to_bits())))); + result.map(|_| ()) +} + +// Line 602 +fn c283_l602_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c283_l602_action_invoke"); + let result = instance.call("f64.no_fold_div_mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000003919745428533519f64).to_bits()), Value::F64((-21314747179654705000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000039197454285335185f64).to_bits())))); + result.map(|_| ()) +} + +// Line 603 +fn c284_l603_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c284_l603_action_invoke"); + let result = instance.call("f64.no_fold_div_mul", &[Value::F64((-5734160003788982000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((6350805843612229000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-5734160003788981000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 607 + +#[test] +fn test_module_34() { + let mut instance = create_module_34(); + // We group the calls together + start_module_34(&mut instance); + c275_l593_action_invoke(&mut instance); + c276_l594_action_invoke(&mut instance); + c277_l595_action_invoke(&mut instance); + c278_l596_action_invoke(&mut instance); + c279_l597_action_invoke(&mut instance); + c280_l599_action_invoke(&mut instance); + c281_l600_action_invoke(&mut instance); + c282_l601_action_invoke(&mut instance); + c283_l602_action_invoke(&mut instance); + c284_l603_action_invoke(&mut instance); +} +fn create_module_35() -> Box { + let module_str = "(module + (type (;0;) (func (param f32) (result f32))) + (type (;1;) (func (param f64) (result f64))) + (func (;0;) (type 0) (param f32) (result f32) + get_local 0 + f32.const 0x1p+1 (;=2;) + f32.div + f32.const 0x1p+1 (;=2;) + f32.mul) + (func (;1;) (type 1) (param f64) (result f64) + get_local 0 + f64.const 0x1p+1 (;=2;) + f64.div + f64.const 0x1p+1 (;=2;) + f64.mul) + (export \"f32.no_fold_div2_mul2\" (func 0)) + (export \"f64.no_fold_div2_mul2\" (func 1))) + "; + 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_35(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 614 +fn c286_l614_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c286_l614_action_invoke"); + let result = instance.call("f32.no_fold_div2_mul2", &[Value::F32((0.000000000000000000000000000000000000023509886f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000023509887f32).to_bits())))); + result.map(|_| ()) +} + +// Line 615 +fn c287_l615_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c287_l615_action_invoke"); + let result = instance.call("f64.no_fold_div2_mul2", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044501477170144023f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004450147717014403f64).to_bits())))); + result.map(|_| ()) +} + +// Line 619 + +#[test] +fn test_module_35() { + let mut instance = create_module_35(); + // We group the calls together + start_module_35(&mut instance); + c286_l614_action_invoke(&mut instance); + c287_l615_action_invoke(&mut instance); +} +fn create_module_36() -> Box { + let module_str = "(module + (type (;0;) (func (param f64) (result f64))) + (func (;0;) (type 0) (param f64) (result f64) + get_local 0 + f32.demote/f64 + f64.promote/f32) + (export \"no_fold_demote_promote\" (func 0))) + "; + 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_36(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 624 +fn c289_l624_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c289_l624_action_invoke"); + let result = instance.call("no_fold_demote_promote", &[Value::F64((-0.00000000000000000000000000000000000000017176297220569481f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000017176275796615013f64).to_bits())))); + result.map(|_| ()) +} + +// Line 625 +fn c290_l625_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c290_l625_action_invoke"); + let result = instance.call("no_fold_demote_promote", &[Value::F64((-0.000000000000000000000000028464775573304055f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000002846477619188087f64).to_bits())))); + result.map(|_| ()) +} + +// Line 626 +fn c291_l626_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c291_l626_action_invoke"); + let result = instance.call("no_fold_demote_promote", &[Value::F64((208970699699909230000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((208970700445326000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 627 +fn c292_l627_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c292_l627_action_invoke"); + let result = instance.call("no_fold_demote_promote", &[Value::F64((-0.0000000000000000000000000047074160416121775f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000000000000047074161331556024f64).to_bits())))); + result.map(|_| ()) +} + +// Line 628 +fn c293_l628_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c293_l628_action_invoke"); + let result = instance.call("no_fold_demote_promote", &[Value::F64((23359451497950880000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((23359452224542198000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 633 + +#[test] +fn test_module_36() { + let mut instance = create_module_36(); + // We group the calls together + start_module_36(&mut instance); + c289_l624_action_invoke(&mut instance); + c290_l625_action_invoke(&mut instance); + c291_l626_action_invoke(&mut instance); + c292_l627_action_invoke(&mut instance); + c293_l628_action_invoke(&mut instance); +} +fn create_module_37() -> Box { + let module_str = "(module + (type (;0;) (func (param f32) (result f32))) + (func (;0;) (type 0) (param f32) (result f32) + get_local 0 + f64.promote/f32 + f32.demote/f64) + (export \"no_fold_promote_demote\" (func 0))) + "; + 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_37(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 638 +fn c295_l638_assert_return_arithmetic_nan(instance: &mut Instance) { + println!("Executing function {}", "c295_l638_assert_return_arithmetic_nan"); + let result = instance.call("no_fold_promote_demote", &[Value::F32(f32::from_bits(2141192192) as u32)]).unwrap().expect("Missing result in c295_l638_assert_return_arithmetic_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 639 +fn c296_l639_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c296_l639_action_invoke"); + let result = instance.call("no_fold_promote_demote", &[Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 640 +fn c297_l640_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c297_l640_action_invoke"); + let result = instance.call("no_fold_promote_demote", &[Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 641 +fn c298_l641_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c298_l641_action_invoke"); + let result = instance.call("no_fold_promote_demote", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 642 +fn c299_l642_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c299_l642_action_invoke"); + let result = instance.call("no_fold_promote_demote", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 643 +fn c300_l643_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c300_l643_action_invoke"); + let result = instance.call("no_fold_promote_demote", &[Value::F32((0.000000000000000000000000000000000000011754942f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754942f32).to_bits())))); + result.map(|_| ()) +} + +// Line 644 +fn c301_l644_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c301_l644_action_invoke"); + let result = instance.call("no_fold_promote_demote", &[Value::F32((-0.000000000000000000000000000000000000011754942f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754942f32).to_bits())))); + result.map(|_| ()) +} + +// Line 645 +fn c302_l645_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c302_l645_action_invoke"); + let result = instance.call("no_fold_promote_demote", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 646 +fn c303_l646_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c303_l646_action_invoke"); + let result = instance.call("no_fold_promote_demote", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 647 +fn c304_l647_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c304_l647_action_invoke"); + let result = instance.call("no_fold_promote_demote", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 648 +fn c305_l648_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c305_l648_action_invoke"); + let result = instance.call("no_fold_promote_demote", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 649 +fn c306_l649_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c306_l649_action_invoke"); + let result = instance.call("no_fold_promote_demote", &[Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 650 +fn c307_l650_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c307_l650_action_invoke"); + let result = instance.call("no_fold_promote_demote", &[Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 654 + +#[test] +fn test_module_37() { + let mut instance = create_module_37(); + // We group the calls together + start_module_37(&mut instance); + c295_l638_assert_return_arithmetic_nan(&mut instance); + c296_l639_action_invoke(&mut instance); + c297_l640_action_invoke(&mut instance); + c298_l641_action_invoke(&mut instance); + c299_l642_action_invoke(&mut instance); + c300_l643_action_invoke(&mut instance); + c301_l644_action_invoke(&mut instance); + c302_l645_action_invoke(&mut instance); + c303_l646_action_invoke(&mut instance); + c304_l647_action_invoke(&mut instance); + c305_l648_action_invoke(&mut instance); + c306_l649_action_invoke(&mut instance); + c307_l650_action_invoke(&mut instance); +} +fn create_module_38() -> Box { + let module_str = "(module + (type (;0;) (func (param f64 f32) (result f32))) + (type (;1;) (func (param f32 f64) (result f32))) + (func (;0;) (type 0) (param f64 f32) (result f32) + get_local 0 + get_local 1 + f64.promote/f32 + f64.add + f32.demote/f64) + (func (;1;) (type 1) (param f32 f64) (result f32) + get_local 0 + f64.promote/f32 + get_local 1 + f64.add + f32.demote/f64) + (export \"no_demote_mixed_add\" (func 0)) + (export \"no_demote_mixed_add_commuted\" (func 1))) + "; + 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_38(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 661 +fn c309_l661_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c309_l661_action_invoke"); + let result = instance.call("no_demote_mixed_add", &[Value::F64((0.00000000000000000000000000004941266527909197f64).to_bits()), Value::F32((0.0000000000000000000000000000000000018767183f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000049412667f32).to_bits())))); + result.map(|_| ()) +} + +// Line 662 +fn c310_l662_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c310_l662_action_invoke"); + let result = instance.call("no_demote_mixed_add", &[Value::F64((140851523637.69385f64).to_bits()), Value::F32((401096440000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((541947950000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 663 +fn c311_l663_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c311_l663_action_invoke"); + let result = instance.call("no_demote_mixed_add", &[Value::F64((0.0000000000000000000000000000000000020831160914192852f64).to_bits()), Value::F32((-0.0000000000000000000000000000000000006050095f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000000000000000000014781066f32).to_bits())))); + result.map(|_| ()) +} + +// Line 664 +fn c312_l664_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c312_l664_action_invoke"); + let result = instance.call("no_demote_mixed_add", &[Value::F64((-0.0000010032827553674626f64).to_bits()), Value::F32((0.0000000019312918f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0000010013515f32).to_bits())))); + result.map(|_| ()) +} + +// Line 665 +fn c313_l665_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c313_l665_action_invoke"); + let result = instance.call("no_demote_mixed_add", &[Value::F64((-0.0000013840207035752711f64).to_bits()), Value::F32((-0.0000000000005202814f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0000013840212f32).to_bits())))); + result.map(|_| ()) +} + +// Line 667 +fn c314_l667_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c314_l667_action_invoke"); + let result = instance.call("no_demote_mixed_add_commuted", &[Value::F32((0.0000000000000000000000000000000000018767183f32).to_bits()), Value::F64((0.00000000000000000000000000004941266527909197f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000049412667f32).to_bits())))); + result.map(|_| ()) +} + +// Line 668 +fn c315_l668_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c315_l668_action_invoke"); + let result = instance.call("no_demote_mixed_add_commuted", &[Value::F32((401096440000.0f32).to_bits()), Value::F64((140851523637.69385f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((541947950000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 669 +fn c316_l669_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c316_l669_action_invoke"); + let result = instance.call("no_demote_mixed_add_commuted", &[Value::F32((-0.0000000000000000000000000000000000006050095f32).to_bits()), Value::F64((0.0000000000000000000000000000000000020831160914192852f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000000000000000000014781066f32).to_bits())))); + result.map(|_| ()) +} + +// Line 670 +fn c317_l670_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c317_l670_action_invoke"); + let result = instance.call("no_demote_mixed_add_commuted", &[Value::F32((0.0000000019312918f32).to_bits()), Value::F64((-0.0000010032827553674626f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0000010013515f32).to_bits())))); + result.map(|_| ()) +} + +// Line 671 +fn c318_l671_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c318_l671_action_invoke"); + let result = instance.call("no_demote_mixed_add_commuted", &[Value::F32((-0.0000000000005202814f32).to_bits()), Value::F64((-0.0000013840207035752711f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0000013840212f32).to_bits())))); + result.map(|_| ()) +} + +// Line 675 + +#[test] +fn test_module_38() { + let mut instance = create_module_38(); + // We group the calls together + start_module_38(&mut instance); + c309_l661_action_invoke(&mut instance); + c310_l662_action_invoke(&mut instance); + c311_l663_action_invoke(&mut instance); + c312_l664_action_invoke(&mut instance); + c313_l665_action_invoke(&mut instance); + c314_l667_action_invoke(&mut instance); + c315_l668_action_invoke(&mut instance); + c316_l669_action_invoke(&mut instance); + c317_l670_action_invoke(&mut instance); + c318_l671_action_invoke(&mut instance); +} +fn create_module_39() -> Box { + let module_str = "(module + (type (;0;) (func (param f64 f32) (result f32))) + (func (;0;) (type 0) (param f64 f32) (result f32) + get_local 0 + get_local 1 + f64.promote/f32 + f64.sub + f32.demote/f64) + (export \"no_demote_mixed_sub\" (func 0))) + "; + 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_39(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 680 +fn c320_l680_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c320_l680_action_invoke"); + let result = instance.call("no_demote_mixed_sub", &[Value::F64((7869935327202668000000000.0f64).to_bits()), Value::F32((4086347000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((7869931000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 681 +fn c321_l681_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c321_l681_action_invoke"); + let result = instance.call("no_demote_mixed_sub", &[Value::F64((-1535841968.9056544f64).to_bits()), Value::F32((239897.28f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1536081900.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 682 +fn c322_l682_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c322_l682_action_invoke"); + let result = instance.call("no_demote_mixed_sub", &[Value::F64((-102.19459272722602f64).to_bits()), Value::F32((0.00039426138f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-102.194984f32).to_bits())))); + result.map(|_| ()) +} + +// Line 683 +fn c323_l683_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c323_l683_action_invoke"); + let result = instance.call("no_demote_mixed_sub", &[Value::F64((0.00000000000000005645470375565188f64).to_bits()), Value::F32((0.0000000000000000000005851077f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.00000000000000005645412f32).to_bits())))); + result.map(|_| ()) +} + +// Line 684 +fn c324_l684_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c324_l684_action_invoke"); + let result = instance.call("no_demote_mixed_sub", &[Value::F64((27090.388466832894f64).to_bits()), Value::F32((63120.89f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-36030.504f32).to_bits())))); + result.map(|_| ()) +} + +// Line 688 + +#[test] +fn test_module_39() { + let mut instance = create_module_39(); + // We group the calls together + start_module_39(&mut instance); + c320_l680_action_invoke(&mut instance); + c321_l681_action_invoke(&mut instance); + c322_l682_action_invoke(&mut instance); + c323_l683_action_invoke(&mut instance); + c324_l684_action_invoke(&mut instance); +} +fn create_module_40() -> Box { + let module_str = "(module + (type (;0;) (func (param f32) (result f32))) + (type (;1;) (func (param f64) (result f64))) + (func (;0;) (type 0) (param f32) (result f32) + get_local 0 + i32.trunc_s/f32 + f32.convert_s/i32) + (func (;1;) (type 0) (param f32) (result f32) + get_local 0 + i32.trunc_u/f32 + f32.convert_s/i32) + (func (;2;) (type 0) (param f32) (result f32) + get_local 0 + i32.trunc_s/f32 + f32.convert_u/i32) + (func (;3;) (type 0) (param f32) (result f32) + get_local 0 + i32.trunc_u/f32 + f32.convert_u/i32) + (func (;4;) (type 1) (param f64) (result f64) + get_local 0 + i32.trunc_s/f64 + f64.convert_s/i32) + (func (;5;) (type 1) (param f64) (result f64) + get_local 0 + i32.trunc_u/f64 + f64.convert_s/i32) + (func (;6;) (type 1) (param f64) (result f64) + get_local 0 + i32.trunc_s/f64 + f64.convert_u/i32) + (func (;7;) (type 1) (param f64) (result f64) + get_local 0 + i32.trunc_u/f64 + f64.convert_u/i32) + (func (;8;) (type 0) (param f32) (result f32) + get_local 0 + i64.trunc_s/f32 + f32.convert_s/i64) + (func (;9;) (type 0) (param f32) (result f32) + get_local 0 + i64.trunc_u/f32 + f32.convert_s/i64) + (func (;10;) (type 0) (param f32) (result f32) + get_local 0 + i64.trunc_s/f32 + f32.convert_u/i64) + (func (;11;) (type 0) (param f32) (result f32) + get_local 0 + i64.trunc_u/f32 + f32.convert_u/i64) + (func (;12;) (type 1) (param f64) (result f64) + get_local 0 + i64.trunc_s/f64 + f64.convert_s/i64) + (func (;13;) (type 1) (param f64) (result f64) + get_local 0 + i64.trunc_u/f64 + f64.convert_s/i64) + (func (;14;) (type 1) (param f64) (result f64) + get_local 0 + i64.trunc_s/f64 + f64.convert_u/i64) + (func (;15;) (type 1) (param f64) (result f64) + get_local 0 + i64.trunc_u/f64 + f64.convert_u/i64) + (export \"f32.i32.no_fold_trunc_s_convert_s\" (func 0)) + (export \"f32.i32.no_fold_trunc_u_convert_s\" (func 1)) + (export \"f32.i32.no_fold_trunc_s_convert_u\" (func 2)) + (export \"f32.i32.no_fold_trunc_u_convert_u\" (func 3)) + (export \"f64.i32.no_fold_trunc_s_convert_s\" (func 4)) + (export \"f64.i32.no_fold_trunc_u_convert_s\" (func 5)) + (export \"f64.i32.no_fold_trunc_s_convert_u\" (func 6)) + (export \"f64.i32.no_fold_trunc_u_convert_u\" (func 7)) + (export \"f32.i64.no_fold_trunc_s_convert_s\" (func 8)) + (export \"f32.i64.no_fold_trunc_u_convert_s\" (func 9)) + (export \"f32.i64.no_fold_trunc_s_convert_u\" (func 10)) + (export \"f32.i64.no_fold_trunc_u_convert_u\" (func 11)) + (export \"f64.i64.no_fold_trunc_s_convert_s\" (func 12)) + (export \"f64.i64.no_fold_trunc_u_convert_s\" (func 13)) + (export \"f64.i64.no_fold_trunc_s_convert_u\" (func 14)) + (export \"f64.i64.no_fold_trunc_u_convert_u\" (func 15))) + "; + 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_40(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 723 +fn c326_l723_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c326_l723_action_invoke"); + let result = instance.call("f32.i32.no_fold_trunc_s_convert_s", &[Value::F32((1.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 724 +fn c327_l724_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c327_l724_action_invoke"); + let result = instance.call("f32.i32.no_fold_trunc_s_convert_s", &[Value::F32((-1.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 725 +fn c328_l725_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c328_l725_action_invoke"); + let result = instance.call("f32.i32.no_fold_trunc_u_convert_s", &[Value::F32((1.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 726 +fn c329_l726_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c329_l726_action_invoke"); + let result = instance.call("f32.i32.no_fold_trunc_u_convert_s", &[Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 727 +fn c330_l727_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c330_l727_action_invoke"); + let result = instance.call("f32.i32.no_fold_trunc_s_convert_u", &[Value::F32((1.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 728 +fn c331_l728_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c331_l728_action_invoke"); + let result = instance.call("f32.i32.no_fold_trunc_s_convert_u", &[Value::F32((-1.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((4294967300.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 729 +fn c332_l729_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c332_l729_action_invoke"); + let result = instance.call("f32.i32.no_fold_trunc_u_convert_u", &[Value::F32((1.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 730 +fn c333_l730_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c333_l730_action_invoke"); + let result = instance.call("f32.i32.no_fold_trunc_u_convert_u", &[Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 732 +fn c334_l732_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c334_l732_action_invoke"); + let result = instance.call("f64.i32.no_fold_trunc_s_convert_s", &[Value::F64((1.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 733 +fn c335_l733_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c335_l733_action_invoke"); + let result = instance.call("f64.i32.no_fold_trunc_s_convert_s", &[Value::F64((-1.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 734 +fn c336_l734_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c336_l734_action_invoke"); + let result = instance.call("f64.i32.no_fold_trunc_u_convert_s", &[Value::F64((1.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 735 +fn c337_l735_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c337_l735_action_invoke"); + let result = instance.call("f64.i32.no_fold_trunc_u_convert_s", &[Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 736 +fn c338_l736_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c338_l736_action_invoke"); + let result = instance.call("f64.i32.no_fold_trunc_s_convert_u", &[Value::F64((1.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 737 +fn c339_l737_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c339_l737_action_invoke"); + let result = instance.call("f64.i32.no_fold_trunc_s_convert_u", &[Value::F64((-1.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((4294967295.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 738 +fn c340_l738_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c340_l738_action_invoke"); + let result = instance.call("f64.i32.no_fold_trunc_u_convert_u", &[Value::F64((1.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 739 +fn c341_l739_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c341_l739_action_invoke"); + let result = instance.call("f64.i32.no_fold_trunc_u_convert_u", &[Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 741 +fn c342_l741_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c342_l741_action_invoke"); + let result = instance.call("f32.i64.no_fold_trunc_s_convert_s", &[Value::F32((1.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 742 +fn c343_l742_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c343_l742_action_invoke"); + let result = instance.call("f32.i64.no_fold_trunc_s_convert_s", &[Value::F32((-1.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 743 +fn c344_l743_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c344_l743_action_invoke"); + let result = instance.call("f32.i64.no_fold_trunc_u_convert_s", &[Value::F32((1.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 744 +fn c345_l744_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c345_l744_action_invoke"); + let result = instance.call("f32.i64.no_fold_trunc_u_convert_s", &[Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 745 +fn c346_l745_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c346_l745_action_invoke"); + let result = instance.call("f32.i64.no_fold_trunc_s_convert_u", &[Value::F32((1.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 746 +fn c347_l746_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c347_l746_action_invoke"); + let result = instance.call("f32.i64.no_fold_trunc_s_convert_u", &[Value::F32((-1.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((18446744000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 747 +fn c348_l747_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c348_l747_action_invoke"); + let result = instance.call("f32.i64.no_fold_trunc_u_convert_u", &[Value::F32((1.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 748 +fn c349_l748_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c349_l748_action_invoke"); + let result = instance.call("f32.i64.no_fold_trunc_u_convert_u", &[Value::F32((-0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 750 +fn c350_l750_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c350_l750_action_invoke"); + let result = instance.call("f64.i64.no_fold_trunc_s_convert_s", &[Value::F64((1.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 751 +fn c351_l751_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c351_l751_action_invoke"); + let result = instance.call("f64.i64.no_fold_trunc_s_convert_s", &[Value::F64((-1.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 752 +fn c352_l752_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c352_l752_action_invoke"); + let result = instance.call("f64.i64.no_fold_trunc_u_convert_s", &[Value::F64((1.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 753 +fn c353_l753_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c353_l753_action_invoke"); + let result = instance.call("f64.i64.no_fold_trunc_u_convert_s", &[Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 754 +fn c354_l754_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c354_l754_action_invoke"); + let result = instance.call("f64.i64.no_fold_trunc_s_convert_u", &[Value::F64((1.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 755 +fn c355_l755_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c355_l755_action_invoke"); + let result = instance.call("f64.i64.no_fold_trunc_s_convert_u", &[Value::F64((-1.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((18446744073709552000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 756 +fn c356_l756_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c356_l756_action_invoke"); + let result = instance.call("f64.i64.no_fold_trunc_u_convert_u", &[Value::F64((1.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 757 +fn c357_l757_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c357_l757_action_invoke"); + let result = instance.call("f64.i64.no_fold_trunc_u_convert_u", &[Value::F64((-0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 763 + +#[test] +fn test_module_40() { + let mut instance = create_module_40(); + // We group the calls together + start_module_40(&mut instance); + c326_l723_action_invoke(&mut instance); + c327_l724_action_invoke(&mut instance); + c328_l725_action_invoke(&mut instance); + c329_l726_action_invoke(&mut instance); + c330_l727_action_invoke(&mut instance); + c331_l728_action_invoke(&mut instance); + c332_l729_action_invoke(&mut instance); + c333_l730_action_invoke(&mut instance); + c334_l732_action_invoke(&mut instance); + c335_l733_action_invoke(&mut instance); + c336_l734_action_invoke(&mut instance); + c337_l735_action_invoke(&mut instance); + c338_l736_action_invoke(&mut instance); + c339_l737_action_invoke(&mut instance); + c340_l738_action_invoke(&mut instance); + c341_l739_action_invoke(&mut instance); + c342_l741_action_invoke(&mut instance); + c343_l742_action_invoke(&mut instance); + c344_l743_action_invoke(&mut instance); + c345_l744_action_invoke(&mut instance); + c346_l745_action_invoke(&mut instance); + c347_l746_action_invoke(&mut instance); + c348_l747_action_invoke(&mut instance); + c349_l748_action_invoke(&mut instance); + c350_l750_action_invoke(&mut instance); + c351_l751_action_invoke(&mut instance); + c352_l752_action_invoke(&mut instance); + c353_l753_action_invoke(&mut instance); + c354_l754_action_invoke(&mut instance); + c355_l755_action_invoke(&mut instance); + c356_l756_action_invoke(&mut instance); + c357_l757_action_invoke(&mut instance); +} +fn create_module_41() -> Box { + let module_str = "(module + (type (;0;) (func (param i32 f32))) + (type (;1;) (func (param i32) (result f32))) + (func (;0;) (type 0) (param i32 f32) + get_local 0 + get_local 1 + f32.store) + (func (;1;) (type 0) (param i32 f32) + (local i32) + block ;; label = @1 + loop ;; label = @2 + get_local 2 + get_local 2 + f32.load + get_local 1 + f32.div + f32.store + get_local 2 + i32.const 4 + i32.add + set_local 2 + get_local 2 + get_local 0 + i32.lt_u + br_if 0 (;@2;) + end + end) + (func (;2;) (type 1) (param i32) (result f32) + get_local 0 + f32.load) + (memory (;0;) 1 1) + (export \"init\" (func 0)) + (export \"run\" (func 1)) + (export \"check\" (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_41(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 784 +fn c359_l784_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c359_l784_action_invoke"); + let result = instance.call("init", &[Value::I32(0 as i32), Value::F32((15.1f32).to_bits())]); + + result.map(|_| ()) +} + +// Line 785 +fn c360_l785_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c360_l785_action_invoke"); + let result = instance.call("init", &[Value::I32(4 as i32), Value::F32((15.2f32).to_bits())]); + + result.map(|_| ()) +} + +// Line 786 +fn c361_l786_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c361_l786_action_invoke"); + let result = instance.call("init", &[Value::I32(8 as i32), Value::F32((15.3f32).to_bits())]); + + result.map(|_| ()) +} + +// Line 787 +fn c362_l787_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c362_l787_action_invoke"); + let result = instance.call("init", &[Value::I32(12 as i32), Value::F32((15.4f32).to_bits())]); + + result.map(|_| ()) +} + +// Line 788 +fn c363_l788_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c363_l788_action_invoke"); + let result = instance.call("check", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((15.1f32).to_bits())))); + result.map(|_| ()) +} + +// Line 789 +fn c364_l789_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c364_l789_action_invoke"); + let result = instance.call("check", &[Value::I32(4 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((15.2f32).to_bits())))); + result.map(|_| ()) +} + +// Line 790 +fn c365_l790_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c365_l790_action_invoke"); + let result = instance.call("check", &[Value::I32(8 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((15.3f32).to_bits())))); + result.map(|_| ()) +} + +// Line 791 +fn c366_l791_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c366_l791_action_invoke"); + let result = instance.call("check", &[Value::I32(12 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((15.4f32).to_bits())))); + result.map(|_| ()) +} + +// Line 792 +fn c367_l792_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c367_l792_action_invoke"); + let result = instance.call("run", &[Value::I32(16 as i32), Value::F32((3.0f32).to_bits())]); + + result.map(|_| ()) +} + +// Line 793 +fn c368_l793_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c368_l793_action_invoke"); + let result = instance.call("check", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((5.0333333f32).to_bits())))); + result.map(|_| ()) +} + +// Line 794 +fn c369_l794_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c369_l794_action_invoke"); + let result = instance.call("check", &[Value::I32(4 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((5.0666666f32).to_bits())))); + result.map(|_| ()) +} + +// Line 795 +fn c370_l795_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c370_l795_action_invoke"); + let result = instance.call("check", &[Value::I32(8 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((5.1f32).to_bits())))); + result.map(|_| ()) +} + +// Line 796 +fn c371_l796_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c371_l796_action_invoke"); + let result = instance.call("check", &[Value::I32(12 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((5.133333f32).to_bits())))); + result.map(|_| ()) +} + +// Line 798 + +#[test] +fn test_module_41() { + let mut instance = create_module_41(); + // We group the calls together + start_module_41(&mut instance); + c359_l784_action_invoke(&mut instance); + c360_l785_action_invoke(&mut instance); + c361_l786_action_invoke(&mut instance); + c362_l787_action_invoke(&mut instance); + c363_l788_action_invoke(&mut instance); + c364_l789_action_invoke(&mut instance); + c365_l790_action_invoke(&mut instance); + c366_l791_action_invoke(&mut instance); + c367_l792_action_invoke(&mut instance); + c368_l793_action_invoke(&mut instance); + c369_l794_action_invoke(&mut instance); + c370_l795_action_invoke(&mut instance); + c371_l796_action_invoke(&mut instance); +} +fn create_module_42() -> Box { + let module_str = "(module + (type (;0;) (func (param i32 f64))) + (type (;1;) (func (param i32) (result f64))) + (func (;0;) (type 0) (param i32 f64) + get_local 0 + get_local 1 + f64.store) + (func (;1;) (type 0) (param i32 f64) + (local i32) + block ;; label = @1 + loop ;; label = @2 + get_local 2 + get_local 2 + f64.load + get_local 1 + f64.div + f64.store + get_local 2 + i32.const 8 + i32.add + set_local 2 + get_local 2 + get_local 0 + i32.lt_u + br_if 0 (;@2;) + end + end) + (func (;2;) (type 1) (param i32) (result f64) + get_local 0 + f64.load) + (memory (;0;) 1 1) + (export \"init\" (func 0)) + (export \"run\" (func 1)) + (export \"check\" (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_42(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 819 +fn c373_l819_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c373_l819_action_invoke"); + let result = instance.call("init", &[Value::I32(0 as i32), Value::F64((15.1f64).to_bits())]); + + result.map(|_| ()) +} + +// Line 820 +fn c374_l820_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c374_l820_action_invoke"); + let result = instance.call("init", &[Value::I32(8 as i32), Value::F64((15.2f64).to_bits())]); + + result.map(|_| ()) +} + +// Line 821 +fn c375_l821_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c375_l821_action_invoke"); + let result = instance.call("init", &[Value::I32(16 as i32), Value::F64((15.3f64).to_bits())]); + + result.map(|_| ()) +} + +// Line 822 +fn c376_l822_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c376_l822_action_invoke"); + let result = instance.call("init", &[Value::I32(24 as i32), Value::F64((15.4f64).to_bits())]); + + result.map(|_| ()) +} + +// Line 823 +fn c377_l823_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c377_l823_action_invoke"); + let result = instance.call("check", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((15.1f64).to_bits())))); + result.map(|_| ()) +} + +// Line 824 +fn c378_l824_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c378_l824_action_invoke"); + let result = instance.call("check", &[Value::I32(8 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((15.2f64).to_bits())))); + result.map(|_| ()) +} + +// Line 825 +fn c379_l825_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c379_l825_action_invoke"); + let result = instance.call("check", &[Value::I32(16 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((15.3f64).to_bits())))); + result.map(|_| ()) +} + +// Line 826 +fn c380_l826_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c380_l826_action_invoke"); + let result = instance.call("check", &[Value::I32(24 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((15.4f64).to_bits())))); + result.map(|_| ()) +} + +// Line 827 +fn c381_l827_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c381_l827_action_invoke"); + let result = instance.call("run", &[Value::I32(32 as i32), Value::F64((3.0f64).to_bits())]); + + result.map(|_| ()) +} + +// Line 828 +fn c382_l828_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c382_l828_action_invoke"); + let result = instance.call("check", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((5.033333333333333f64).to_bits())))); + result.map(|_| ()) +} + +// Line 829 +fn c383_l829_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c383_l829_action_invoke"); + let result = instance.call("check", &[Value::I32(8 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((5.066666666666666f64).to_bits())))); + result.map(|_| ()) +} + +// Line 830 +fn c384_l830_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c384_l830_action_invoke"); + let result = instance.call("check", &[Value::I32(16 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((5.1000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 831 +fn c385_l831_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c385_l831_action_invoke"); + let result = instance.call("check", &[Value::I32(24 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((5.133333333333334f64).to_bits())))); + result.map(|_| ()) +} + +// Line 835 + +#[test] +fn test_module_42() { + let mut instance = create_module_42(); + // We group the calls together + start_module_42(&mut instance); + c373_l819_action_invoke(&mut instance); + c374_l820_action_invoke(&mut instance); + c375_l821_action_invoke(&mut instance); + c376_l822_action_invoke(&mut instance); + c377_l823_action_invoke(&mut instance); + c378_l824_action_invoke(&mut instance); + c379_l825_action_invoke(&mut instance); + c380_l826_action_invoke(&mut instance); + c381_l827_action_invoke(&mut instance); + c382_l828_action_invoke(&mut instance); + c383_l829_action_invoke(&mut instance); + c384_l830_action_invoke(&mut instance); + c385_l831_action_invoke(&mut instance); +} +fn create_module_43() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32) (result i32))) + (type (;1;) (func (param f64 f64) (result i32))) + (func (;0;) (type 0) (param f32 f32) (result i32) + get_local 0 + get_local 1 + f32.ge + i32.eqz) + (func (;1;) (type 0) (param f32 f32) (result i32) + get_local 0 + get_local 1 + f32.gt + i32.eqz) + (func (;2;) (type 0) (param f32 f32) (result i32) + get_local 0 + get_local 1 + f32.le + i32.eqz) + (func (;3;) (type 0) (param f32 f32) (result i32) + get_local 0 + get_local 1 + f32.lt + i32.eqz) + (func (;4;) (type 1) (param f64 f64) (result i32) + get_local 0 + get_local 1 + f64.ge + i32.eqz) + (func (;5;) (type 1) (param f64 f64) (result i32) + get_local 0 + get_local 1 + f64.gt + i32.eqz) + (func (;6;) (type 1) (param f64 f64) (result i32) + get_local 0 + get_local 1 + f64.le + i32.eqz) + (func (;7;) (type 1) (param f64 f64) (result i32) + get_local 0 + get_local 1 + f64.lt + i32.eqz) + (export \"f32.ult\" (func 0)) + (export \"f32.ule\" (func 1)) + (export \"f32.ugt\" (func 2)) + (export \"f32.uge\" (func 3)) + (export \"f64.ult\" (func 4)) + (export \"f64.ule\" (func 5)) + (export \"f64.ugt\" (func 6)) + (export \"f64.uge\" (func 7))) + "; + 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_43(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 847 +fn c387_l847_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c387_l847_action_invoke"); + let result = instance.call("f32.ult", &[Value::F32((3.0f32).to_bits()), Value::F32((2.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 848 +fn c388_l848_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c388_l848_action_invoke"); + let result = instance.call("f32.ult", &[Value::F32((2.0f32).to_bits()), Value::F32((2.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 849 +fn c389_l849_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c389_l849_action_invoke"); + let result = instance.call("f32.ult", &[Value::F32((2.0f32).to_bits()), Value::F32((3.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 850 +fn c390_l850_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c390_l850_action_invoke"); + let result = instance.call("f32.ult", &[Value::F32((2.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 851 +fn c391_l851_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c391_l851_action_invoke"); + let result = instance.call("f32.ule", &[Value::F32((3.0f32).to_bits()), Value::F32((2.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 852 +fn c392_l852_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c392_l852_action_invoke"); + let result = instance.call("f32.ule", &[Value::F32((2.0f32).to_bits()), Value::F32((2.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 853 +fn c393_l853_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c393_l853_action_invoke"); + let result = instance.call("f32.ule", &[Value::F32((2.0f32).to_bits()), Value::F32((3.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 854 +fn c394_l854_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c394_l854_action_invoke"); + let result = instance.call("f32.ule", &[Value::F32((2.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 855 +fn c395_l855_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c395_l855_action_invoke"); + let result = instance.call("f32.ugt", &[Value::F32((3.0f32).to_bits()), Value::F32((2.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 856 +fn c396_l856_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c396_l856_action_invoke"); + let result = instance.call("f32.ugt", &[Value::F32((2.0f32).to_bits()), Value::F32((2.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 857 +fn c397_l857_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c397_l857_action_invoke"); + let result = instance.call("f32.ugt", &[Value::F32((2.0f32).to_bits()), Value::F32((3.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 858 +fn c398_l858_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c398_l858_action_invoke"); + let result = instance.call("f32.ugt", &[Value::F32((2.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 859 +fn c399_l859_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c399_l859_action_invoke"); + let result = instance.call("f32.uge", &[Value::F32((3.0f32).to_bits()), Value::F32((2.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 860 +fn c400_l860_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c400_l860_action_invoke"); + let result = instance.call("f32.uge", &[Value::F32((2.0f32).to_bits()), Value::F32((2.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 861 +fn c401_l861_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c401_l861_action_invoke"); + let result = instance.call("f32.uge", &[Value::F32((2.0f32).to_bits()), Value::F32((3.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 862 +fn c402_l862_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c402_l862_action_invoke"); + let result = instance.call("f32.uge", &[Value::F32((2.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 863 +fn c403_l863_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c403_l863_action_invoke"); + let result = instance.call("f64.ult", &[Value::F64((3.0f64).to_bits()), Value::F64((2.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 864 +fn c404_l864_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c404_l864_action_invoke"); + let result = instance.call("f64.ult", &[Value::F64((2.0f64).to_bits()), Value::F64((2.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 865 +fn c405_l865_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c405_l865_action_invoke"); + let result = instance.call("f64.ult", &[Value::F64((2.0f64).to_bits()), Value::F64((3.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 866 +fn c406_l866_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c406_l866_action_invoke"); + let result = instance.call("f64.ult", &[Value::F64((2.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 867 +fn c407_l867_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c407_l867_action_invoke"); + let result = instance.call("f64.ule", &[Value::F64((3.0f64).to_bits()), Value::F64((2.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 868 +fn c408_l868_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c408_l868_action_invoke"); + let result = instance.call("f64.ule", &[Value::F64((2.0f64).to_bits()), Value::F64((2.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 869 +fn c409_l869_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c409_l869_action_invoke"); + let result = instance.call("f64.ule", &[Value::F64((2.0f64).to_bits()), Value::F64((3.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 870 +fn c410_l870_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c410_l870_action_invoke"); + let result = instance.call("f64.ule", &[Value::F64((2.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 871 +fn c411_l871_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c411_l871_action_invoke"); + let result = instance.call("f64.ugt", &[Value::F64((3.0f64).to_bits()), Value::F64((2.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 872 +fn c412_l872_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c412_l872_action_invoke"); + let result = instance.call("f64.ugt", &[Value::F64((2.0f64).to_bits()), Value::F64((2.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 873 +fn c413_l873_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c413_l873_action_invoke"); + let result = instance.call("f64.ugt", &[Value::F64((2.0f64).to_bits()), Value::F64((3.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 874 +fn c414_l874_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c414_l874_action_invoke"); + let result = instance.call("f64.ugt", &[Value::F64((2.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 875 +fn c415_l875_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c415_l875_action_invoke"); + let result = instance.call("f64.uge", &[Value::F64((3.0f64).to_bits()), Value::F64((2.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 876 +fn c416_l876_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c416_l876_action_invoke"); + let result = instance.call("f64.uge", &[Value::F64((2.0f64).to_bits()), Value::F64((2.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 877 +fn c417_l877_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c417_l877_action_invoke"); + let result = instance.call("f64.uge", &[Value::F64((2.0f64).to_bits()), Value::F64((3.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 878 +fn c418_l878_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c418_l878_action_invoke"); + let result = instance.call("f64.uge", &[Value::F64((2.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 882 + +#[test] +fn test_module_43() { + let mut instance = create_module_43(); + // We group the calls together + start_module_43(&mut instance); + c387_l847_action_invoke(&mut instance); + c388_l848_action_invoke(&mut instance); + c389_l849_action_invoke(&mut instance); + c390_l850_action_invoke(&mut instance); + c391_l851_action_invoke(&mut instance); + c392_l852_action_invoke(&mut instance); + c393_l853_action_invoke(&mut instance); + c394_l854_action_invoke(&mut instance); + c395_l855_action_invoke(&mut instance); + c396_l856_action_invoke(&mut instance); + c397_l857_action_invoke(&mut instance); + c398_l858_action_invoke(&mut instance); + c399_l859_action_invoke(&mut instance); + c400_l860_action_invoke(&mut instance); + c401_l861_action_invoke(&mut instance); + c402_l862_action_invoke(&mut instance); + c403_l863_action_invoke(&mut instance); + c404_l864_action_invoke(&mut instance); + c405_l865_action_invoke(&mut instance); + c406_l866_action_invoke(&mut instance); + c407_l867_action_invoke(&mut instance); + c408_l868_action_invoke(&mut instance); + c409_l869_action_invoke(&mut instance); + c410_l870_action_invoke(&mut instance); + c411_l871_action_invoke(&mut instance); + c412_l872_action_invoke(&mut instance); + c413_l873_action_invoke(&mut instance); + c414_l874_action_invoke(&mut instance); + c415_l875_action_invoke(&mut instance); + c416_l876_action_invoke(&mut instance); + c417_l877_action_invoke(&mut instance); + c418_l878_action_invoke(&mut instance); +} +fn create_module_44() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32) (result f32))) + (type (;1;) (func (param f64 f64) (result f64))) + (func (;0;) (type 0) (param f32 f32) (result f32) + get_local 0 + get_local 1 + get_local 0 + get_local 1 + f32.lt + select) + (func (;1;) (type 0) (param f32 f32) (result f32) + get_local 0 + get_local 1 + get_local 0 + get_local 1 + f32.le + select) + (func (;2;) (type 0) (param f32 f32) (result f32) + get_local 0 + get_local 1 + get_local 0 + get_local 1 + f32.gt + select) + (func (;3;) (type 0) (param f32 f32) (result f32) + get_local 0 + get_local 1 + get_local 0 + get_local 1 + f32.ge + select) + (func (;4;) (type 1) (param f64 f64) (result f64) + get_local 0 + get_local 1 + get_local 0 + get_local 1 + f64.lt + select) + (func (;5;) (type 1) (param f64 f64) (result f64) + get_local 0 + get_local 1 + get_local 0 + get_local 1 + f64.le + select) + (func (;6;) (type 1) (param f64 f64) (result f64) + get_local 0 + get_local 1 + get_local 0 + get_local 1 + f64.gt + select) + (func (;7;) (type 1) (param f64 f64) (result f64) + get_local 0 + get_local 1 + get_local 0 + get_local 1 + f64.ge + select) + (export \"f32.no_fold_lt_select\" (func 0)) + (export \"f32.no_fold_le_select\" (func 1)) + (export \"f32.no_fold_gt_select\" (func 2)) + (export \"f32.no_fold_ge_select\" (func 3)) + (export \"f64.no_fold_lt_select\" (func 4)) + (export \"f64.no_fold_le_select\" (func 5)) + (export \"f64.no_fold_gt_select\" (func 6)) + (export \"f64.no_fold_ge_select\" (func 7))) + "; + 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_44(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 894 +fn c420_l894_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c420_l894_action_invoke"); + let result = instance.call("f32.no_fold_lt_select", &[Value::F32((0.0f32).to_bits()), 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 895 +fn c421_l895_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c421_l895_action_invoke"); + let result = instance.call("f32.no_fold_lt_select", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 896 +fn c422_l896_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c422_l896_action_invoke"); + let result = instance.call("f32.no_fold_lt_select", &[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 897 +fn c423_l897_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c423_l897_action_invoke"); + let result = instance.call("f32.no_fold_lt_select", &[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 898 +fn c424_l898_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c424_l898_action_invoke"); + let result = instance.call("f32.no_fold_le_select", &[Value::F32((0.0f32).to_bits()), 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 899 +fn c425_l899_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c425_l899_action_invoke"); + let result = instance.call("f32.no_fold_le_select", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 900 +fn c426_l900_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c426_l900_action_invoke"); + let result = instance.call("f32.no_fold_le_select", &[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 901 +fn c427_l901_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c427_l901_action_invoke"); + let result = instance.call("f32.no_fold_le_select", &[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 902 +fn c428_l902_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c428_l902_action_invoke"); + let result = instance.call("f32.no_fold_gt_select", &[Value::F32((0.0f32).to_bits()), 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 903 +fn c429_l903_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c429_l903_action_invoke"); + let result = instance.call("f32.no_fold_gt_select", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 904 +fn c430_l904_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c430_l904_action_invoke"); + let result = instance.call("f32.no_fold_gt_select", &[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 905 +fn c431_l905_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c431_l905_action_invoke"); + let result = instance.call("f32.no_fold_gt_select", &[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 906 +fn c432_l906_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c432_l906_action_invoke"); + let result = instance.call("f32.no_fold_ge_select", &[Value::F32((0.0f32).to_bits()), 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 907 +fn c433_l907_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c433_l907_action_invoke"); + let result = instance.call("f32.no_fold_ge_select", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 908 +fn c434_l908_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c434_l908_action_invoke"); + let result = instance.call("f32.no_fold_ge_select", &[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 909 +fn c435_l909_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c435_l909_action_invoke"); + let result = instance.call("f32.no_fold_ge_select", &[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 910 +fn c436_l910_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c436_l910_action_invoke"); + let result = instance.call("f64.no_fold_lt_select", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + let expected = f64::from_bits(9221120237041090560); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 911 +fn c437_l911_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c437_l911_action_invoke"); + let result = instance.call("f64.no_fold_lt_select", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 912 +fn c438_l912_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c438_l912_action_invoke"); + let result = instance.call("f64.no_fold_lt_select", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 913 +fn c439_l913_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c439_l913_action_invoke"); + let result = instance.call("f64.no_fold_lt_select", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 914 +fn c440_l914_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c440_l914_action_invoke"); + let result = instance.call("f64.no_fold_le_select", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + let expected = f64::from_bits(9221120237041090560); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 915 +fn c441_l915_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c441_l915_action_invoke"); + let result = instance.call("f64.no_fold_le_select", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 916 +fn c442_l916_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c442_l916_action_invoke"); + let result = instance.call("f64.no_fold_le_select", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 917 +fn c443_l917_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c443_l917_action_invoke"); + let result = instance.call("f64.no_fold_le_select", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 918 +fn c444_l918_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c444_l918_action_invoke"); + let result = instance.call("f64.no_fold_gt_select", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + let expected = f64::from_bits(9221120237041090560); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 919 +fn c445_l919_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c445_l919_action_invoke"); + let result = instance.call("f64.no_fold_gt_select", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 920 +fn c446_l920_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c446_l920_action_invoke"); + let result = instance.call("f64.no_fold_gt_select", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 921 +fn c447_l921_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c447_l921_action_invoke"); + let result = instance.call("f64.no_fold_gt_select", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 922 +fn c448_l922_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c448_l922_action_invoke"); + let result = instance.call("f64.no_fold_ge_select", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + let expected = f64::from_bits(9221120237041090560); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 923 +fn c449_l923_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c449_l923_action_invoke"); + let result = instance.call("f64.no_fold_ge_select", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 924 +fn c450_l924_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c450_l924_action_invoke"); + let result = instance.call("f64.no_fold_ge_select", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 925 +fn c451_l925_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c451_l925_action_invoke"); + let result = instance.call("f64.no_fold_ge_select", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 929 + +#[test] +fn test_module_44() { + let mut instance = create_module_44(); + // We group the calls together + start_module_44(&mut instance); + c420_l894_action_invoke(&mut instance); + c421_l895_action_invoke(&mut instance); + c422_l896_action_invoke(&mut instance); + c423_l897_action_invoke(&mut instance); + c424_l898_action_invoke(&mut instance); + c425_l899_action_invoke(&mut instance); + c426_l900_action_invoke(&mut instance); + c427_l901_action_invoke(&mut instance); + c428_l902_action_invoke(&mut instance); + c429_l903_action_invoke(&mut instance); + c430_l904_action_invoke(&mut instance); + c431_l905_action_invoke(&mut instance); + c432_l906_action_invoke(&mut instance); + c433_l907_action_invoke(&mut instance); + c434_l908_action_invoke(&mut instance); + c435_l909_action_invoke(&mut instance); + c436_l910_action_invoke(&mut instance); + c437_l911_action_invoke(&mut instance); + c438_l912_action_invoke(&mut instance); + c439_l913_action_invoke(&mut instance); + c440_l914_action_invoke(&mut instance); + c441_l915_action_invoke(&mut instance); + c442_l916_action_invoke(&mut instance); + c443_l917_action_invoke(&mut instance); + c444_l918_action_invoke(&mut instance); + c445_l919_action_invoke(&mut instance); + c446_l920_action_invoke(&mut instance); + c447_l921_action_invoke(&mut instance); + c448_l922_action_invoke(&mut instance); + c449_l923_action_invoke(&mut instance); + c450_l924_action_invoke(&mut instance); + c451_l925_action_invoke(&mut instance); +} +fn create_module_45() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32) (result f32))) + (type (;1;) (func (param f64 f64) (result f64))) + (func (;0;) (type 0) (param f32 f32) (result f32) + get_local 0 + get_local 1 + f32.lt + if (result f32) ;; label = @1 + get_local 0 + else + get_local 1 + end) + (func (;1;) (type 0) (param f32 f32) (result f32) + get_local 0 + get_local 1 + f32.le + if (result f32) ;; label = @1 + get_local 0 + else + get_local 1 + end) + (func (;2;) (type 0) (param f32 f32) (result f32) + get_local 0 + get_local 1 + f32.gt + if (result f32) ;; label = @1 + get_local 0 + else + get_local 1 + end) + (func (;3;) (type 0) (param f32 f32) (result f32) + get_local 0 + get_local 1 + f32.ge + if (result f32) ;; label = @1 + get_local 0 + else + get_local 1 + end) + (func (;4;) (type 1) (param f64 f64) (result f64) + get_local 0 + get_local 1 + f64.lt + if (result f64) ;; label = @1 + get_local 0 + else + get_local 1 + end) + (func (;5;) (type 1) (param f64 f64) (result f64) + get_local 0 + get_local 1 + f64.le + if (result f64) ;; label = @1 + get_local 0 + else + get_local 1 + end) + (func (;6;) (type 1) (param f64 f64) (result f64) + get_local 0 + get_local 1 + f64.gt + if (result f64) ;; label = @1 + get_local 0 + else + get_local 1 + end) + (func (;7;) (type 1) (param f64 f64) (result f64) + get_local 0 + get_local 1 + f64.ge + if (result f64) ;; label = @1 + get_local 0 + else + get_local 1 + end) + (export \"f32.no_fold_lt_if\" (func 0)) + (export \"f32.no_fold_le_if\" (func 1)) + (export \"f32.no_fold_gt_if\" (func 2)) + (export \"f32.no_fold_ge_if\" (func 3)) + (export \"f64.no_fold_lt_if\" (func 4)) + (export \"f64.no_fold_le_if\" (func 5)) + (export \"f64.no_fold_gt_if\" (func 6)) + (export \"f64.no_fold_ge_if\" (func 7))) + "; + 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_45(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 973 +fn c453_l973_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c453_l973_action_invoke"); + let result = instance.call("f32.no_fold_lt_if", &[Value::F32((0.0f32).to_bits()), 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 974 +fn c454_l974_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c454_l974_action_invoke"); + let result = instance.call("f32.no_fold_lt_if", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 975 +fn c455_l975_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c455_l975_action_invoke"); + let result = instance.call("f32.no_fold_lt_if", &[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 976 +fn c456_l976_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c456_l976_action_invoke"); + let result = instance.call("f32.no_fold_lt_if", &[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 977 +fn c457_l977_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c457_l977_action_invoke"); + let result = instance.call("f32.no_fold_le_if", &[Value::F32((0.0f32).to_bits()), 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 978 +fn c458_l978_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c458_l978_action_invoke"); + let result = instance.call("f32.no_fold_le_if", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 979 +fn c459_l979_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c459_l979_action_invoke"); + let result = instance.call("f32.no_fold_le_if", &[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 980 +fn c460_l980_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c460_l980_action_invoke"); + let result = instance.call("f32.no_fold_le_if", &[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 981 +fn c461_l981_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c461_l981_action_invoke"); + let result = instance.call("f32.no_fold_gt_if", &[Value::F32((0.0f32).to_bits()), 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 982 +fn c462_l982_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c462_l982_action_invoke"); + let result = instance.call("f32.no_fold_gt_if", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 983 +fn c463_l983_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c463_l983_action_invoke"); + let result = instance.call("f32.no_fold_gt_if", &[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 984 +fn c464_l984_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c464_l984_action_invoke"); + let result = instance.call("f32.no_fold_gt_if", &[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 985 +fn c465_l985_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c465_l985_action_invoke"); + let result = instance.call("f32.no_fold_ge_if", &[Value::F32((0.0f32).to_bits()), 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 986 +fn c466_l986_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c466_l986_action_invoke"); + let result = instance.call("f32.no_fold_ge_if", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 987 +fn c467_l987_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c467_l987_action_invoke"); + let result = instance.call("f32.no_fold_ge_if", &[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 988 +fn c468_l988_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c468_l988_action_invoke"); + let result = instance.call("f32.no_fold_ge_if", &[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 989 +fn c469_l989_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c469_l989_action_invoke"); + let result = instance.call("f64.no_fold_lt_if", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + let expected = f64::from_bits(9221120237041090560); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 990 +fn c470_l990_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c470_l990_action_invoke"); + let result = instance.call("f64.no_fold_lt_if", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 991 +fn c471_l991_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c471_l991_action_invoke"); + let result = instance.call("f64.no_fold_lt_if", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 992 +fn c472_l992_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c472_l992_action_invoke"); + let result = instance.call("f64.no_fold_lt_if", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 993 +fn c473_l993_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c473_l993_action_invoke"); + let result = instance.call("f64.no_fold_le_if", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + let expected = f64::from_bits(9221120237041090560); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 994 +fn c474_l994_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c474_l994_action_invoke"); + let result = instance.call("f64.no_fold_le_if", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 995 +fn c475_l995_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c475_l995_action_invoke"); + let result = instance.call("f64.no_fold_le_if", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 996 +fn c476_l996_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c476_l996_action_invoke"); + let result = instance.call("f64.no_fold_le_if", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 997 +fn c477_l997_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c477_l997_action_invoke"); + let result = instance.call("f64.no_fold_gt_if", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + let expected = f64::from_bits(9221120237041090560); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 998 +fn c478_l998_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c478_l998_action_invoke"); + let result = instance.call("f64.no_fold_gt_if", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 999 +fn c479_l999_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c479_l999_action_invoke"); + let result = instance.call("f64.no_fold_gt_if", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1000 +fn c480_l1000_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c480_l1000_action_invoke"); + let result = instance.call("f64.no_fold_gt_if", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1001 +fn c481_l1001_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c481_l1001_action_invoke"); + let result = instance.call("f64.no_fold_ge_if", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + let expected = f64::from_bits(9221120237041090560); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 1002 +fn c482_l1002_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c482_l1002_action_invoke"); + let result = instance.call("f64.no_fold_ge_if", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1003 +fn c483_l1003_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c483_l1003_action_invoke"); + let result = instance.call("f64.no_fold_ge_if", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1004 +fn c484_l1004_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c484_l1004_action_invoke"); + let result = instance.call("f64.no_fold_ge_if", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1008 + +#[test] +fn test_module_45() { + let mut instance = create_module_45(); + // We group the calls together + start_module_45(&mut instance); + c453_l973_action_invoke(&mut instance); + c454_l974_action_invoke(&mut instance); + c455_l975_action_invoke(&mut instance); + c456_l976_action_invoke(&mut instance); + c457_l977_action_invoke(&mut instance); + c458_l978_action_invoke(&mut instance); + c459_l979_action_invoke(&mut instance); + c460_l980_action_invoke(&mut instance); + c461_l981_action_invoke(&mut instance); + c462_l982_action_invoke(&mut instance); + c463_l983_action_invoke(&mut instance); + c464_l984_action_invoke(&mut instance); + c465_l985_action_invoke(&mut instance); + c466_l986_action_invoke(&mut instance); + c467_l987_action_invoke(&mut instance); + c468_l988_action_invoke(&mut instance); + c469_l989_action_invoke(&mut instance); + c470_l990_action_invoke(&mut instance); + c471_l991_action_invoke(&mut instance); + c472_l992_action_invoke(&mut instance); + c473_l993_action_invoke(&mut instance); + c474_l994_action_invoke(&mut instance); + c475_l995_action_invoke(&mut instance); + c476_l996_action_invoke(&mut instance); + c477_l997_action_invoke(&mut instance); + c478_l998_action_invoke(&mut instance); + c479_l999_action_invoke(&mut instance); + c480_l1000_action_invoke(&mut instance); + c481_l1001_action_invoke(&mut instance); + c482_l1002_action_invoke(&mut instance); + c483_l1003_action_invoke(&mut instance); + c484_l1004_action_invoke(&mut instance); +} +fn create_module_46() -> Box { + let module_str = "(module + (type (;0;) (func (param f32) (result f32))) + (type (;1;) (func (param f64) (result f64))) + (func (;0;) (type 0) (param f32) (result f32) + get_local 0 + f32.neg + get_local 0 + get_local 0 + f32.const 0x0p+0 (;=0;) + f32.lt + select) + (func (;1;) (type 0) (param f32) (result f32) + get_local 0 + f32.neg + get_local 0 + get_local 0 + f32.const -0x0p+0 (;=-0;) + f32.le + select) + (func (;2;) (type 0) (param f32) (result f32) + get_local 0 + get_local 0 + f32.neg + get_local 0 + f32.const -0x0p+0 (;=-0;) + f32.gt + select) + (func (;3;) (type 0) (param f32) (result f32) + get_local 0 + get_local 0 + f32.neg + get_local 0 + f32.const 0x0p+0 (;=0;) + f32.ge + select) + (func (;4;) (type 1) (param f64) (result f64) + get_local 0 + f64.neg + get_local 0 + get_local 0 + f64.const 0x0p+0 (;=0;) + f64.lt + select) + (func (;5;) (type 1) (param f64) (result f64) + get_local 0 + f64.neg + get_local 0 + get_local 0 + f64.const -0x0p+0 (;=-0;) + f64.le + select) + (func (;6;) (type 1) (param f64) (result f64) + get_local 0 + get_local 0 + f64.neg + get_local 0 + f64.const -0x0p+0 (;=-0;) + f64.gt + select) + (func (;7;) (type 1) (param f64) (result f64) + get_local 0 + get_local 0 + f64.neg + get_local 0 + f64.const 0x0p+0 (;=0;) + f64.ge + select) + (export \"f32.no_fold_lt_select_to_abs\" (func 0)) + (export \"f32.no_fold_le_select_to_abs\" (func 1)) + (export \"f32.no_fold_gt_select_to_abs\" (func 2)) + (export \"f32.no_fold_ge_select_to_abs\" (func 3)) + (export \"f64.no_fold_lt_select_to_abs\" (func 4)) + (export \"f64.no_fold_le_select_to_abs\" (func 5)) + (export \"f64.no_fold_gt_select_to_abs\" (func 6)) + (export \"f64.no_fold_ge_select_to_abs\" (func 7))) + "; + 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_46(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 1020 +fn c486_l1020_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c486_l1020_action_invoke"); + let result = instance.call("f32.no_fold_lt_select_to_abs", &[Value::F32(f32::from_bits(2141192192) as u32)]); + let expected = f32::from_bits(2141192192); + 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 1021 +fn c487_l1021_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c487_l1021_action_invoke"); + let result = instance.call("f32.no_fold_lt_select_to_abs", &[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 1022 +fn c488_l1022_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c488_l1022_action_invoke"); + let result = instance.call("f32.no_fold_lt_select_to_abs", &[Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1023 +fn c489_l1023_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c489_l1023_action_invoke"); + let result = instance.call("f32.no_fold_lt_select_to_abs", &[Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1024 +fn c490_l1024_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c490_l1024_action_invoke"); + let result = instance.call("f32.no_fold_le_select_to_abs", &[Value::F32(f32::from_bits(2141192192) as u32)]); + let expected = f32::from_bits(2141192192); + 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 1025 +fn c491_l1025_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c491_l1025_action_invoke"); + let result = instance.call("f32.no_fold_le_select_to_abs", &[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 1026 +fn c492_l1026_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c492_l1026_action_invoke"); + let result = instance.call("f32.no_fold_le_select_to_abs", &[Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1027 +fn c493_l1027_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c493_l1027_action_invoke"); + let result = instance.call("f32.no_fold_le_select_to_abs", &[Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1028 +fn c494_l1028_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c494_l1028_action_invoke"); + let result = instance.call("f32.no_fold_gt_select_to_abs", &[Value::F32(f32::from_bits(2141192192) as u32)]); + let expected = f32::from_bits(4288675840); + 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 1029 +fn c495_l1029_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c495_l1029_action_invoke"); + let result = instance.call("f32.no_fold_gt_select_to_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 1030 +fn c496_l1030_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c496_l1030_action_invoke"); + let result = instance.call("f32.no_fold_gt_select_to_abs", &[Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1031 +fn c497_l1031_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c497_l1031_action_invoke"); + let result = instance.call("f32.no_fold_gt_select_to_abs", &[Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1032 +fn c498_l1032_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c498_l1032_action_invoke"); + let result = instance.call("f32.no_fold_ge_select_to_abs", &[Value::F32(f32::from_bits(2141192192) as u32)]); + let expected = f32::from_bits(4288675840); + 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 1033 +fn c499_l1033_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c499_l1033_action_invoke"); + let result = instance.call("f32.no_fold_ge_select_to_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 1034 +fn c500_l1034_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c500_l1034_action_invoke"); + let result = instance.call("f32.no_fold_ge_select_to_abs", &[Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1035 +fn c501_l1035_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c501_l1035_action_invoke"); + let result = instance.call("f32.no_fold_ge_select_to_abs", &[Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1036 +fn c502_l1036_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c502_l1036_action_invoke"); + let result = instance.call("f64.no_fold_lt_select_to_abs", &[Value::F64(f64::from_bits(9219994337134247936) as u64)]); + let expected = f64::from_bits(9219994337134247936); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 1037 +fn c503_l1037_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c503_l1037_action_invoke"); + let result = instance.call("f64.no_fold_lt_select_to_abs", &[Value::F64(f64::from_bits(18444492273895866368) as u64)]); + let expected = f64::from_bits(18444492273895866368); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 1038 +fn c504_l1038_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c504_l1038_action_invoke"); + let result = instance.call("f64.no_fold_lt_select_to_abs", &[Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1039 +fn c505_l1039_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c505_l1039_action_invoke"); + let result = instance.call("f64.no_fold_lt_select_to_abs", &[Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1040 +fn c506_l1040_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c506_l1040_action_invoke"); + let result = instance.call("f64.no_fold_le_select_to_abs", &[Value::F64(f64::from_bits(9219994337134247936) as u64)]); + let expected = f64::from_bits(9219994337134247936); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 1041 +fn c507_l1041_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c507_l1041_action_invoke"); + let result = instance.call("f64.no_fold_le_select_to_abs", &[Value::F64(f64::from_bits(18444492273895866368) as u64)]); + let expected = f64::from_bits(18444492273895866368); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 1042 +fn c508_l1042_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c508_l1042_action_invoke"); + let result = instance.call("f64.no_fold_le_select_to_abs", &[Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1043 +fn c509_l1043_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c509_l1043_action_invoke"); + let result = instance.call("f64.no_fold_le_select_to_abs", &[Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1044 +fn c510_l1044_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c510_l1044_action_invoke"); + let result = instance.call("f64.no_fold_gt_select_to_abs", &[Value::F64(f64::from_bits(9219994337134247936) as u64)]); + let expected = f64::from_bits(18443366373989023744); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 1045 +fn c511_l1045_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c511_l1045_action_invoke"); + let result = instance.call("f64.no_fold_gt_select_to_abs", &[Value::F64(f64::from_bits(18444492273895866368) as u64)]); + let expected = f64::from_bits(9221120237041090560); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 1046 +fn c512_l1046_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c512_l1046_action_invoke"); + let result = instance.call("f64.no_fold_gt_select_to_abs", &[Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1047 +fn c513_l1047_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c513_l1047_action_invoke"); + let result = instance.call("f64.no_fold_gt_select_to_abs", &[Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1048 +fn c514_l1048_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c514_l1048_action_invoke"); + let result = instance.call("f64.no_fold_ge_select_to_abs", &[Value::F64(f64::from_bits(9219994337134247936) as u64)]); + let expected = f64::from_bits(18443366373989023744); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 1049 +fn c515_l1049_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c515_l1049_action_invoke"); + let result = instance.call("f64.no_fold_ge_select_to_abs", &[Value::F64(f64::from_bits(18444492273895866368) as u64)]); + let expected = f64::from_bits(9221120237041090560); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 1050 +fn c516_l1050_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c516_l1050_action_invoke"); + let result = instance.call("f64.no_fold_ge_select_to_abs", &[Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1051 +fn c517_l1051_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c517_l1051_action_invoke"); + let result = instance.call("f64.no_fold_ge_select_to_abs", &[Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1055 + +#[test] +fn test_module_46() { + let mut instance = create_module_46(); + // We group the calls together + start_module_46(&mut instance); + c486_l1020_action_invoke(&mut instance); + c487_l1021_action_invoke(&mut instance); + c488_l1022_action_invoke(&mut instance); + c489_l1023_action_invoke(&mut instance); + c490_l1024_action_invoke(&mut instance); + c491_l1025_action_invoke(&mut instance); + c492_l1026_action_invoke(&mut instance); + c493_l1027_action_invoke(&mut instance); + c494_l1028_action_invoke(&mut instance); + c495_l1029_action_invoke(&mut instance); + c496_l1030_action_invoke(&mut instance); + c497_l1031_action_invoke(&mut instance); + c498_l1032_action_invoke(&mut instance); + c499_l1033_action_invoke(&mut instance); + c500_l1034_action_invoke(&mut instance); + c501_l1035_action_invoke(&mut instance); + c502_l1036_action_invoke(&mut instance); + c503_l1037_action_invoke(&mut instance); + c504_l1038_action_invoke(&mut instance); + c505_l1039_action_invoke(&mut instance); + c506_l1040_action_invoke(&mut instance); + c507_l1041_action_invoke(&mut instance); + c508_l1042_action_invoke(&mut instance); + c509_l1043_action_invoke(&mut instance); + c510_l1044_action_invoke(&mut instance); + c511_l1045_action_invoke(&mut instance); + c512_l1046_action_invoke(&mut instance); + c513_l1047_action_invoke(&mut instance); + c514_l1048_action_invoke(&mut instance); + c515_l1049_action_invoke(&mut instance); + c516_l1050_action_invoke(&mut instance); + c517_l1051_action_invoke(&mut instance); +} +fn create_module_47() -> Box { + let module_str = "(module + (type (;0;) (func (param f32) (result f32))) + (type (;1;) (func (param f64) (result f64))) + (func (;0;) (type 0) (param f32) (result f32) + get_local 0 + f32.const 0x0p+0 (;=0;) + f32.lt + if (result f32) ;; label = @1 + get_local 0 + f32.neg + else + get_local 0 + end) + (func (;1;) (type 0) (param f32) (result f32) + get_local 0 + f32.const -0x0p+0 (;=-0;) + f32.le + if (result f32) ;; label = @1 + get_local 0 + f32.neg + else + get_local 0 + end) + (func (;2;) (type 0) (param f32) (result f32) + get_local 0 + f32.const -0x0p+0 (;=-0;) + f32.gt + if (result f32) ;; label = @1 + get_local 0 + else + get_local 0 + f32.neg + end) + (func (;3;) (type 0) (param f32) (result f32) + get_local 0 + f32.const 0x0p+0 (;=0;) + f32.ge + if (result f32) ;; label = @1 + get_local 0 + else + get_local 0 + f32.neg + end) + (func (;4;) (type 1) (param f64) (result f64) + get_local 0 + f64.const 0x0p+0 (;=0;) + f64.lt + if (result f64) ;; label = @1 + get_local 0 + f64.neg + else + get_local 0 + end) + (func (;5;) (type 1) (param f64) (result f64) + get_local 0 + f64.const -0x0p+0 (;=-0;) + f64.le + if (result f64) ;; label = @1 + get_local 0 + f64.neg + else + get_local 0 + end) + (func (;6;) (type 1) (param f64) (result f64) + get_local 0 + f64.const -0x0p+0 (;=-0;) + f64.gt + if (result f64) ;; label = @1 + get_local 0 + else + get_local 0 + f64.neg + end) + (func (;7;) (type 1) (param f64) (result f64) + get_local 0 + f64.const 0x0p+0 (;=0;) + f64.ge + if (result f64) ;; label = @1 + get_local 0 + else + get_local 0 + f64.neg + end) + (export \"f32.no_fold_lt_if_to_abs\" (func 0)) + (export \"f32.no_fold_le_if_to_abs\" (func 1)) + (export \"f32.no_fold_gt_if_to_abs\" (func 2)) + (export \"f32.no_fold_ge_if_to_abs\" (func 3)) + (export \"f64.no_fold_lt_if_to_abs\" (func 4)) + (export \"f64.no_fold_le_if_to_abs\" (func 5)) + (export \"f64.no_fold_gt_if_to_abs\" (func 6)) + (export \"f64.no_fold_ge_if_to_abs\" (func 7))) + "; + 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_47(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 1099 +fn c519_l1099_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c519_l1099_action_invoke"); + let result = instance.call("f32.no_fold_lt_if_to_abs", &[Value::F32(f32::from_bits(2141192192) as u32)]); + let expected = f32::from_bits(2141192192); + 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 1100 +fn c520_l1100_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c520_l1100_action_invoke"); + let result = instance.call("f32.no_fold_lt_if_to_abs", &[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 1101 +fn c521_l1101_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c521_l1101_action_invoke"); + let result = instance.call("f32.no_fold_lt_if_to_abs", &[Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1102 +fn c522_l1102_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c522_l1102_action_invoke"); + let result = instance.call("f32.no_fold_lt_if_to_abs", &[Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1103 +fn c523_l1103_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c523_l1103_action_invoke"); + let result = instance.call("f32.no_fold_le_if_to_abs", &[Value::F32(f32::from_bits(2141192192) as u32)]); + let expected = f32::from_bits(2141192192); + 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 1104 +fn c524_l1104_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c524_l1104_action_invoke"); + let result = instance.call("f32.no_fold_le_if_to_abs", &[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 1105 +fn c525_l1105_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c525_l1105_action_invoke"); + let result = instance.call("f32.no_fold_le_if_to_abs", &[Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1106 +fn c526_l1106_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c526_l1106_action_invoke"); + let result = instance.call("f32.no_fold_le_if_to_abs", &[Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1107 +fn c527_l1107_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c527_l1107_action_invoke"); + let result = instance.call("f32.no_fold_gt_if_to_abs", &[Value::F32(f32::from_bits(2141192192) as u32)]); + let expected = f32::from_bits(4288675840); + 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 1108 +fn c528_l1108_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c528_l1108_action_invoke"); + let result = instance.call("f32.no_fold_gt_if_to_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 1109 +fn c529_l1109_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c529_l1109_action_invoke"); + let result = instance.call("f32.no_fold_gt_if_to_abs", &[Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1110 +fn c530_l1110_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c530_l1110_action_invoke"); + let result = instance.call("f32.no_fold_gt_if_to_abs", &[Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1111 +fn c531_l1111_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c531_l1111_action_invoke"); + let result = instance.call("f32.no_fold_ge_if_to_abs", &[Value::F32(f32::from_bits(2141192192) as u32)]); + let expected = f32::from_bits(4288675840); + 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 1112 +fn c532_l1112_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c532_l1112_action_invoke"); + let result = instance.call("f32.no_fold_ge_if_to_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 1113 +fn c533_l1113_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c533_l1113_action_invoke"); + let result = instance.call("f32.no_fold_ge_if_to_abs", &[Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1114 +fn c534_l1114_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c534_l1114_action_invoke"); + let result = instance.call("f32.no_fold_ge_if_to_abs", &[Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1115 +fn c535_l1115_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c535_l1115_action_invoke"); + let result = instance.call("f64.no_fold_lt_if_to_abs", &[Value::F64(f64::from_bits(9219994337134247936) as u64)]); + let expected = f64::from_bits(9219994337134247936); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 1116 +fn c536_l1116_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c536_l1116_action_invoke"); + let result = instance.call("f64.no_fold_lt_if_to_abs", &[Value::F64(f64::from_bits(18444492273895866368) as u64)]); + let expected = f64::from_bits(18444492273895866368); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 1117 +fn c537_l1117_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c537_l1117_action_invoke"); + let result = instance.call("f64.no_fold_lt_if_to_abs", &[Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1118 +fn c538_l1118_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c538_l1118_action_invoke"); + let result = instance.call("f64.no_fold_lt_if_to_abs", &[Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1119 +fn c539_l1119_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c539_l1119_action_invoke"); + let result = instance.call("f64.no_fold_le_if_to_abs", &[Value::F64(f64::from_bits(9219994337134247936) as u64)]); + let expected = f64::from_bits(9219994337134247936); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 1120 +fn c540_l1120_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c540_l1120_action_invoke"); + let result = instance.call("f64.no_fold_le_if_to_abs", &[Value::F64(f64::from_bits(18444492273895866368) as u64)]); + let expected = f64::from_bits(18444492273895866368); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 1121 +fn c541_l1121_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c541_l1121_action_invoke"); + let result = instance.call("f64.no_fold_le_if_to_abs", &[Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1122 +fn c542_l1122_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c542_l1122_action_invoke"); + let result = instance.call("f64.no_fold_le_if_to_abs", &[Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1123 +fn c543_l1123_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c543_l1123_action_invoke"); + let result = instance.call("f64.no_fold_gt_if_to_abs", &[Value::F64(f64::from_bits(9219994337134247936) as u64)]); + let expected = f64::from_bits(18443366373989023744); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 1124 +fn c544_l1124_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c544_l1124_action_invoke"); + let result = instance.call("f64.no_fold_gt_if_to_abs", &[Value::F64(f64::from_bits(18444492273895866368) as u64)]); + let expected = f64::from_bits(9221120237041090560); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 1125 +fn c545_l1125_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c545_l1125_action_invoke"); + let result = instance.call("f64.no_fold_gt_if_to_abs", &[Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1126 +fn c546_l1126_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c546_l1126_action_invoke"); + let result = instance.call("f64.no_fold_gt_if_to_abs", &[Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1127 +fn c547_l1127_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c547_l1127_action_invoke"); + let result = instance.call("f64.no_fold_ge_if_to_abs", &[Value::F64(f64::from_bits(9219994337134247936) as u64)]); + let expected = f64::from_bits(18443366373989023744); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 1128 +fn c548_l1128_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c548_l1128_action_invoke"); + let result = instance.call("f64.no_fold_ge_if_to_abs", &[Value::F64(f64::from_bits(18444492273895866368) as u64)]); + let expected = f64::from_bits(9221120237041090560); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 1129 +fn c549_l1129_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c549_l1129_action_invoke"); + let result = instance.call("f64.no_fold_ge_if_to_abs", &[Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1130 +fn c550_l1130_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c550_l1130_action_invoke"); + let result = instance.call("f64.no_fold_ge_if_to_abs", &[Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1135 + +#[test] +fn test_module_47() { + let mut instance = create_module_47(); + // We group the calls together + start_module_47(&mut instance); + c519_l1099_action_invoke(&mut instance); + c520_l1100_action_invoke(&mut instance); + c521_l1101_action_invoke(&mut instance); + c522_l1102_action_invoke(&mut instance); + c523_l1103_action_invoke(&mut instance); + c524_l1104_action_invoke(&mut instance); + c525_l1105_action_invoke(&mut instance); + c526_l1106_action_invoke(&mut instance); + c527_l1107_action_invoke(&mut instance); + c528_l1108_action_invoke(&mut instance); + c529_l1109_action_invoke(&mut instance); + c530_l1110_action_invoke(&mut instance); + c531_l1111_action_invoke(&mut instance); + c532_l1112_action_invoke(&mut instance); + c533_l1113_action_invoke(&mut instance); + c534_l1114_action_invoke(&mut instance); + c535_l1115_action_invoke(&mut instance); + c536_l1116_action_invoke(&mut instance); + c537_l1117_action_invoke(&mut instance); + c538_l1118_action_invoke(&mut instance); + c539_l1119_action_invoke(&mut instance); + c540_l1120_action_invoke(&mut instance); + c541_l1121_action_invoke(&mut instance); + c542_l1122_action_invoke(&mut instance); + c543_l1123_action_invoke(&mut instance); + c544_l1124_action_invoke(&mut instance); + c545_l1125_action_invoke(&mut instance); + c546_l1126_action_invoke(&mut instance); + c547_l1127_action_invoke(&mut instance); + c548_l1128_action_invoke(&mut instance); + c549_l1129_action_invoke(&mut instance); + c550_l1130_action_invoke(&mut instance); +} +fn create_module_48() -> Box { + let module_str = "(module + (type (;0;) (func (result f32))) + (type (;1;) (func (result f64))) + (func (;0;) (type 0) (result f32) + f32.const 0x1.553f7cp+0 (;=1.333;) + f32.const 0x1.39999ap+0 (;=1.225;) + f32.add + f32.const 0x1.553f7cp+0 (;=1.333;) + f32.sub + f32.const 0x1.39999ap+0 (;=1.225;) + f32.sub) + (func (;1;) (type 1) (result f64) + f64.const 0x1.553f7ced91687p+0 (;=1.333;) + f64.const 0x1.399999999999ap+0 (;=1.225;) + f64.add + f64.const 0x1.553f7ced91687p+0 (;=1.333;) + f64.sub + f64.const 0x1.399999999999ap+0 (;=1.225;) + f64.sub) + (export \"f32.incorrect_correction\" (func 0)) + (export \"f64.incorrect_correction\" (func 1))) + "; + 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_48(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 1144 +fn c552_l1144_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c552_l1144_action_invoke"); + let result = instance.call("f32.incorrect_correction", &[]); + assert_eq!(result, Ok(Some(Value::F32((0.00000011920929f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1145 +fn c553_l1145_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c553_l1145_action_invoke"); + let result = instance.call("f64.incorrect_correction", &[]); + assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000002220446049250313f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1150 + +#[test] +fn test_module_48() { + let mut instance = create_module_48(); + // We group the calls together + start_module_48(&mut instance); + c552_l1144_action_invoke(&mut instance); + c553_l1145_action_invoke(&mut instance); +} +fn create_module_49() -> Box { + let module_str = "(module + (type (;0;) (func (result f32))) + (func (;0;) (type 0) (result f32) + (local f32 f32 f32 f32 f32) + f32.const 0x1.388p+7 (;=156.25;) + set_local 0 + f32.const 0x1.a0aaaap+7 (;=208.333;) + set_local 1 + f32.const 0x1.c78e2ap+0 (;=1.77951;) + set_local 2 + get_local 1 + f32.neg + get_local 0 + f32.mul + get_local 0 + get_local 2 + f32.mul + get_local 1 + f32.sub + f32.div + set_local 3 + get_local 1 + f32.neg + get_local 0 + f32.mul + get_local 0 + get_local 2 + f32.mul + get_local 1 + f32.sub + f32.div + set_local 4 + block ;; label = @1 + get_local 3 + get_local 4 + f32.eq + br_if 0 (;@1;) + unreachable + end + get_local 4) + (export \"calculate\" (func 0))) + "; + 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_49(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 1167 +fn c555_l1167_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c555_l1167_action_invoke"); + let result = instance.call("calculate", &[]); + assert_eq!(result, Ok(Some(Value::F32((-466.92685f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1169 + +#[test] +fn test_module_49() { + let mut instance = create_module_49(); + // We group the calls together + start_module_49(&mut instance); + c555_l1167_action_invoke(&mut instance); +} +fn create_module_50() -> Box { + let module_str = "(module + (type (;0;) (func (result f64))) + (func (;0;) (type 0) (result f64) + (local f64 f64 f64 f64 f64) + f64.const 0x1.388p+7 (;=156.25;) + set_local 0 + f64.const 0x1.a0aaaaaab064bp+7 (;=208.333;) + set_local 1 + f64.const 0x1.c78e2aae3d096p+0 (;=1.77951;) + set_local 2 + get_local 1 + f64.neg + get_local 0 + f64.mul + get_local 0 + get_local 2 + f64.mul + get_local 1 + f64.sub + f64.div + set_local 3 + get_local 1 + f64.neg + get_local 0 + f64.mul + get_local 0 + get_local 2 + f64.mul + get_local 1 + f64.sub + f64.div + set_local 4 + block ;; label = @1 + get_local 3 + get_local 4 + f64.eq + br_if 0 (;@1;) + unreachable + end + get_local 4) + (export \"calculate\" (func 0))) + "; + 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_50(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 1186 +fn c557_l1186_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c557_l1186_action_invoke"); + let result = instance.call("calculate", &[]); + assert_eq!(result, Ok(Some(Value::F64((-466.926956301738f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1191 + +#[test] +fn test_module_50() { + let mut instance = create_module_50(); + // We group the calls together + start_module_50(&mut instance); + c557_l1186_action_invoke(&mut instance); +} +fn create_module_51() -> Box { + let module_str = "(module + (type (;0;) (func (param f32) (result f32))) + (func (;0;) (type 0) (param f32) (result f32) + f32.const 0x0p+0 (;=0;) + f32.const -0x0p+0 (;=-0;) + get_local 0 + f32.sub + f32.sub) + (export \"llvm_pr26746\" (func 0))) + "; + 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_51(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 1197 +fn c559_l1197_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c559_l1197_action_invoke"); + let result = instance.call("llvm_pr26746", &[Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1202 + +#[test] +fn test_module_51() { + let mut instance = create_module_51(); + // We group the calls together + start_module_51(&mut instance); + c559_l1197_action_invoke(&mut instance); +} +fn create_module_52() -> Box { + let module_str = "(module + (type (;0;) (func (param i32) (result f32))) + (func (;0;) (type 0) (param i32) (result f32) + get_local 0 + i32.const 268435455 + i32.and + f32.convert_s/i32 + f32.const -0x1p+23 (;=-8.38861e+06;) + f32.add) + (export \"llvm_pr27153\" (func 0))) + "; + 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_52(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 1208 +fn c561_l1208_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c561_l1208_action_invoke"); + let result = instance.call("llvm_pr27153", &[Value::I32(33554434 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((25165824.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1213 + +#[test] +fn test_module_52() { + let mut instance = create_module_52(); + // We group the calls together + start_module_52(&mut instance); + c561_l1208_action_invoke(&mut instance); +} +fn create_module_53() -> Box { + let module_str = "(module + (type (;0;) (func (param i32 i32) (result f32))) + (func (;0;) (type 0) (param i32 i32) (result f32) + get_local 0 + i32.const -25034805 + i32.or + f32.convert_s/i32 + get_local 1 + i32.const 14942208 + i32.and + f32.convert_s/i32 + f32.add) + (export \"llvm_pr27036\" (func 0))) + "; + 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_53(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 1220 +fn c563_l1220_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c563_l1220_action_invoke"); + let result = instance.call("llvm_pr27036", &[Value::I32(-25034805 as i32), Value::I32(14942208 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((-10092596.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1230 + +#[test] +fn test_module_53() { + let mut instance = create_module_53(); + // We group the calls together + start_module_53(&mut instance); + c563_l1220_action_invoke(&mut instance); +} +fn create_module_54() -> Box { + let module_str = "(module + (type (;0;) (func (param f64 f64 f64 f64) (result f64))) + (type (;1;) (func (param f64 f64 f64) (result f64))) + (type (;2;) (func (param f32 f32 f32) (result f32))) + (func (;0;) (type 0) (param f64 f64 f64 f64) (result f64) + get_local 0 + get_local 1 + f64.mul + get_local 2 + get_local 3 + f64.mul + f64.div) + (func (;1;) (type 1) (param f64 f64 f64) (result f64) + get_local 0 + get_local 1 + f64.mul + get_local 2 + f64.sub) + (func (;2;) (type 2) (param f32 f32 f32) (result f32) + get_local 0 + get_local 1 + f32.mul + get_local 2 + f32.mul) + (export \"thepast0\" (func 0)) + (export \"thepast1\" (func 1)) + (export \"thepast2\" (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_54(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 1244 +fn c565_l1244_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c565_l1244_action_invoke"); + let result = instance.call("thepast0", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004450147717014403f64).to_bits()), Value::F64((0.9999999999999999f64).to_bits()), Value::F64((2.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044501477170144023f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1245 +fn c566_l1245_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c566_l1245_action_invoke"); + let result = instance.call("thepast1", &[Value::F64((0.00000000000000005551115123125783f64).to_bits()), Value::F64((0.9999999999999999f64).to_bits()), Value::F64((0.00000000000000005551115123125783f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000006162975822039155f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1246 +fn c567_l1246_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c567_l1246_action_invoke"); + let result = instance.call("thepast2", &[Value::F32((0.000000000000000000000000000000000000023509887f32).to_bits()), Value::F32((0.5f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1251 + +#[test] +fn test_module_54() { + let mut instance = create_module_54(); + // We group the calls together + start_module_54(&mut instance); + c565_l1244_action_invoke(&mut instance); + c566_l1245_action_invoke(&mut instance); + c567_l1246_action_invoke(&mut instance); +} +fn create_module_55() -> Box { + let module_str = "(module + (type (;0;) (func (param f32) (result f32))) + (func (;0;) (type 0) (param f32) (result f32) + f32.const 0x1p+0 (;=1;) + get_local 0 + f32.div) + (export \"inverse\" (func 0))) + "; + 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_55(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 1257 +fn c569_l1257_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c569_l1257_action_invoke"); + let result = instance.call("inverse", &[Value::F32((96.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.010416667f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1262 + +#[test] +fn test_module_55() { + let mut instance = create_module_55(); + // We group the calls together + start_module_55(&mut instance); + c569_l1257_action_invoke(&mut instance); +} +fn create_module_56() -> Box { + let module_str = "(module + (type (;0;) (func (param f32) (result f32))) + (type (;1;) (func (param f64) (result f64))) + (func (;0;) (type 0) (param f32) (result f32) + get_local 0 + f32.sqrt + f32.const 0x1p+1 (;=2;) + f32.sub) + (func (;1;) (type 1) (param f64) (result f64) + get_local 0 + f64.sqrt + f64.const 0x1p+1 (;=2;) + f64.sub) + (export \"f32_sqrt_minus_2\" (func 0)) + (export \"f64_sqrt_minus_2\" (func 1))) + "; + 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_56(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 1272 +fn c571_l1272_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c571_l1272_action_invoke"); + let result = instance.call("f32_sqrt_minus_2", &[Value::F32((4.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1273 +fn c572_l1273_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c572_l1273_action_invoke"); + let result = instance.call("f64_sqrt_minus_2", &[Value::F64((4.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1277 + +#[test] +fn test_module_56() { + let mut instance = create_module_56(); + // We group the calls together + start_module_56(&mut instance); + c571_l1272_action_invoke(&mut instance); + c572_l1273_action_invoke(&mut instance); +} +fn create_module_57() -> Box { + let module_str = "(module + (type (;0;) (func (param f32) (result f32))) + (type (;1;) (func (param f64) (result f64))) + (func (;0;) (type 0) (param f32) (result f32) + f32.const 0x1p+0 (;=1;) + f32.const 0x1p+0 (;=1;) + get_local 0 + f32.div + f32.div) + (func (;1;) (type 1) (param f64) (result f64) + f64.const 0x1p+0 (;=1;) + f64.const 0x1p+0 (;=1;) + get_local 0 + f64.div + f64.div) + (export \"f32.no_fold_recip_recip\" (func 0)) + (export \"f64.no_fold_recip_recip\" (func 1))) + "; + 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_57(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 1285 +fn c574_l1285_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c574_l1285_action_invoke"); + let result = instance.call("f32.no_fold_recip_recip", &[Value::F32((-70435790000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-70435784000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1286 +fn c575_l1286_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c575_l1286_action_invoke"); + let result = instance.call("f32.no_fold_recip_recip", &[Value::F32((0.000000000000000000000012466101f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000000124661f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1287 +fn c576_l1287_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c576_l1287_action_invoke"); + let result = instance.call("f32.no_fold_recip_recip", &[Value::F32((0.000000000000000000097184545f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000009718455f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1288 +fn c577_l1288_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c577_l1288_action_invoke"); + let result = instance.call("f32.no_fold_recip_recip", &[Value::F32((-30.400759f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-30.40076f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1289 +fn c578_l1289_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c578_l1289_action_invoke"); + let result = instance.call("f32.no_fold_recip_recip", &[Value::F32((2331659200000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((2331659000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1291 +fn c579_l1291_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c579_l1291_action_invoke"); + let result = instance.call("f32.no_fold_recip_recip", &[Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1292 +fn c580_l1292_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c580_l1292_action_invoke"); + let result = instance.call("f32.no_fold_recip_recip", &[Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1293 +fn c581_l1293_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c581_l1293_action_invoke"); + let result = instance.call("f32.no_fold_recip_recip", &[Value::F32(f32::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1294 +fn c582_l1294_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c582_l1294_action_invoke"); + let result = instance.call("f32.no_fold_recip_recip", &[Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1296 +fn c583_l1296_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c583_l1296_action_invoke"); + let result = instance.call("f64.no_fold_recip_recip", &[Value::F64((-657971534362886860000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-657971534362886900000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1297 +fn c584_l1297_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c584_l1297_action_invoke"); + let result = instance.call("f64.no_fold_recip_recip", &[Value::F64((-144246931868576430000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-144246931868576420000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1298 +fn c585_l1298_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c585_l1298_action_invoke"); + let result = instance.call("f64.no_fold_recip_recip", &[Value::F64((184994689206231350000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((184994689206231330000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1299 +fn c586_l1299_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c586_l1299_action_invoke"); + let result = instance.call("f64.no_fold_recip_recip", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005779584288006583f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005779584288006582f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1300 +fn c587_l1300_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c587_l1300_action_invoke"); + let result = instance.call("f64.no_fold_recip_recip", &[Value::F64((51501178696141640000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((51501178696141634000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1302 +fn c588_l1302_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c588_l1302_action_invoke"); + let result = instance.call("f64.no_fold_recip_recip", &[Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1303 +fn c589_l1303_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c589_l1303_action_invoke"); + let result = instance.call("f64.no_fold_recip_recip", &[Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1304 +fn c590_l1304_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c590_l1304_action_invoke"); + let result = instance.call("f64.no_fold_recip_recip", &[Value::F64(f64::NEG_INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1305 +fn c591_l1305_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c591_l1305_action_invoke"); + let result = instance.call("f64.no_fold_recip_recip", &[Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1309 + +#[test] +fn test_module_57() { + let mut instance = create_module_57(); + // We group the calls together + start_module_57(&mut instance); + c574_l1285_action_invoke(&mut instance); + c575_l1286_action_invoke(&mut instance); + c576_l1287_action_invoke(&mut instance); + c577_l1288_action_invoke(&mut instance); + c578_l1289_action_invoke(&mut instance); + c579_l1291_action_invoke(&mut instance); + c580_l1292_action_invoke(&mut instance); + c581_l1293_action_invoke(&mut instance); + c582_l1294_action_invoke(&mut instance); + c583_l1296_action_invoke(&mut instance); + c584_l1297_action_invoke(&mut instance); + c585_l1298_action_invoke(&mut instance); + c586_l1299_action_invoke(&mut instance); + c587_l1300_action_invoke(&mut instance); + c588_l1302_action_invoke(&mut instance); + c589_l1303_action_invoke(&mut instance); + c590_l1304_action_invoke(&mut instance); + c591_l1305_action_invoke(&mut instance); +} +fn create_module_58() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32) (result f32))) + (type (;1;) (func (param f64 f64) (result f64))) + (func (;0;) (type 0) (param f32 f32) (result f32) + get_local 0 + get_local 1 + f32.add + get_local 0 + get_local 1 + f32.sub + f32.mul) + (func (;1;) (type 1) (param f64 f64) (result f64) + get_local 0 + get_local 1 + f64.add + get_local 0 + get_local 1 + f64.sub + f64.mul) + (export \"f32.no_algebraic_factoring\" (func 0)) + (export \"f64.no_algebraic_factoring\" (func 1))) + "; + 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_58(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 1319 +fn c593_l1319_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c593_l1319_action_invoke"); + let result = instance.call("f32.no_algebraic_factoring", &[Value::F32((-0.000000000000000053711865f32).to_bits()), Value::F32((0.00000000000000009744328f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000006610229f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1320 +fn c594_l1320_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c594_l1320_action_invoke"); + let result = instance.call("f32.no_algebraic_factoring", &[Value::F32((-19756732.0f32).to_bits()), Value::F32((32770204.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-683557800000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1321 +fn c595_l1321_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c595_l1321_action_invoke"); + let result = instance.call("f32.no_algebraic_factoring", &[Value::F32((52314150000000.0f32).to_bits()), Value::F32((-145309980000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-18378221000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1322 +fn c596_l1322_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c596_l1322_action_invoke"); + let result = instance.call("f32.no_algebraic_factoring", &[Value::F32((195260.38f32).to_bits()), Value::F32((-227.75723f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((38126563000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1323 +fn c597_l1323_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c597_l1323_action_invoke"); + let result = instance.call("f32.no_algebraic_factoring", &[Value::F32((-237.48706f32).to_bits()), Value::F32((-972341.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-945447960000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1325 +fn c598_l1325_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c598_l1325_action_invoke"); + let result = instance.call("f64.no_algebraic_factoring", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009639720335949767f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008019175443606207f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006430717386609473f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1326 +fn c599_l1326_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c599_l1326_action_invoke"); + let result = instance.call("f64.no_algebraic_factoring", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005166066590392027f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001494333315888213f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000026688244016362468f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1327 +fn c600_l1327_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c600_l1327_action_invoke"); + let result = instance.call("f64.no_algebraic_factoring", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002866135870517635f64).to_bits()), Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012114355254268516f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014675678175314036f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1328 +fn c601_l1328_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c601_l1328_action_invoke"); + let result = instance.call("f64.no_algebraic_factoring", &[Value::F64((-1292099281007814900000000000000000000000000000000000000.0f64).to_bits()), Value::F64((662717187728034000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-439192401389602300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1329 +fn c602_l1329_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c602_l1329_action_invoke"); + let result = instance.call("f64.no_algebraic_factoring", &[Value::F64((26242795689010570000000000000000000.0f64).to_bits()), Value::F64((-1625023398605080200000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((688684325575149100000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1333 + +#[test] +fn test_module_58() { + let mut instance = create_module_58(); + // We group the calls together + start_module_58(&mut instance); + c593_l1319_action_invoke(&mut instance); + c594_l1320_action_invoke(&mut instance); + c595_l1321_action_invoke(&mut instance); + c596_l1322_action_invoke(&mut instance); + c597_l1323_action_invoke(&mut instance); + c598_l1325_action_invoke(&mut instance); + c599_l1326_action_invoke(&mut instance); + c600_l1327_action_invoke(&mut instance); + c601_l1328_action_invoke(&mut instance); + c602_l1329_action_invoke(&mut instance); +} +fn create_module_59() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32) (result f32))) + (type (;1;) (func (param f64 f64) (result f64))) + (func (;0;) (type 0) (param f32 f32) (result f32) + get_local 0 + get_local 0 + f32.mul + get_local 1 + get_local 1 + f32.mul + f32.sub) + (func (;1;) (type 1) (param f64 f64) (result f64) + get_local 0 + get_local 0 + f64.mul + get_local 1 + get_local 1 + f64.mul + f64.sub) + (export \"f32.no_algebraic_factoring\" (func 0)) + (export \"f64.no_algebraic_factoring\" (func 1))) + "; + 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_59(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 1343 +fn c604_l1343_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c604_l1343_action_invoke"); + let result = instance.call("f32.no_algebraic_factoring", &[Value::F32((0.000000000000022102996f32).to_bits()), Value::F32((0.0000000000031465275f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0000000000000000000000099001476f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1344 +fn c605_l1344_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c605_l1344_action_invoke"); + let result = instance.call("f32.no_algebraic_factoring", &[Value::F32((-3289460800000.0f32).to_bits()), Value::F32((-15941539000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((10820299000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1345 +fn c606_l1345_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c606_l1345_action_invoke"); + let result = instance.call("f32.no_algebraic_factoring", &[Value::F32((0.00036497542f32).to_bits()), Value::F32((-0.00016153714f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000107112804f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1346 +fn c607_l1346_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c607_l1346_action_invoke"); + let result = instance.call("f32.no_algebraic_factoring", &[Value::F32((0.000000000000065383266f32).to_bits()), Value::F32((-0.000000000000027412773f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000003523511f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1347 +fn c608_l1347_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c608_l1347_action_invoke"); + let result = instance.call("f32.no_algebraic_factoring", &[Value::F32((3609682000000000.0f32).to_bits()), Value::F32((-5260104400000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-14638896000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1349 +fn c609_l1349_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c609_l1349_action_invoke"); + let result = instance.call("f64.no_algebraic_factoring", &[Value::F64((213640454349895100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-292858755839442800000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((45642243734743850000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1350 +fn c610_l1350_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c610_l1350_action_invoke"); + let result = instance.call("f64.no_algebraic_factoring", &[Value::F64((-1229017115924435800000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-8222158919016600000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-67603897289562710000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1351 +fn c611_l1351_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c611_l1351_action_invoke"); + let result = instance.call("f64.no_algebraic_factoring", &[Value::F64((5477733829752.252f64).to_bits()), Value::F64((-970738900948.5906f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((29063233895797397000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1352 +fn c612_l1352_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c612_l1352_action_invoke"); + let result = instance.call("f64.no_algebraic_factoring", &[Value::F64((-10689141744923551000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-173378393593738040000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((114257751213007240000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1353 +fn c613_l1353_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c613_l1353_action_invoke"); + let result = instance.call("f64.no_algebraic_factoring", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000010295699877022106f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000008952274637805908f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000025858214767010105f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1358 + +#[test] +fn test_module_59() { + let mut instance = create_module_59(); + // We group the calls together + start_module_59(&mut instance); + c604_l1343_action_invoke(&mut instance); + c605_l1344_action_invoke(&mut instance); + c606_l1345_action_invoke(&mut instance); + c607_l1346_action_invoke(&mut instance); + c608_l1347_action_invoke(&mut instance); + c609_l1349_action_invoke(&mut instance); + c610_l1350_action_invoke(&mut instance); + c611_l1351_action_invoke(&mut instance); + c612_l1352_action_invoke(&mut instance); + c613_l1353_action_invoke(&mut instance); +} +fn create_module_60() -> Box { + let module_str = "(module + (type (;0;) (func (param i32 i32 i32))) + (type (;1;) (func (param i32) (result f32))) + (func (;0;) (type 0) (param i32 i32 i32) + (local f32 f32 f32 f32 f32 f32 f32 f32) + get_local 0 + f32.load + set_local 3 + get_local 0 + f32.load offset=4 + set_local 4 + get_local 0 + f32.load offset=8 + set_local 5 + get_local 0 + f32.load offset=12 + set_local 6 + get_local 1 + f32.load + set_local 7 + get_local 1 + f32.load offset=4 + set_local 8 + get_local 1 + f32.load offset=8 + set_local 9 + get_local 1 + f32.load offset=12 + set_local 10 + get_local 2 + get_local 3 + get_local 7 + f32.add + f32.store + get_local 2 + get_local 4 + get_local 8 + f32.add + f32.store offset=4 + get_local 2 + get_local 5 + get_local 9 + f32.add + f32.store offset=8 + get_local 2 + get_local 6 + get_local 10 + f32.add + f32.store offset=12) + (func (;1;) (type 1) (param i32) (result f32) + get_local 0 + f32.load) + (memory (;0;) 1 1) + (export \"f32.simple_x4_sum\" (func 0)) + (export \"f32.load\" (func 1)) + (data (;0;) (i32.const 0) \"\\01\\00\\00\\00\\01\\00\\00\\80\\01\\00\\00\\00\\01\\00\\00\\80\\01\\00\\00\\00\\01\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\")) + "; + 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_60(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 1391 +fn c615_l1391_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c615_l1391_action_invoke"); + let result = instance.call("f32.simple_x4_sum", &[Value::I32(0 as i32), Value::I32(16 as i32), Value::I32(32 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 1392 +fn c616_l1392_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c616_l1392_action_invoke"); + let result = instance.call("f32.load", &[Value::I32(32 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000003f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1393 +fn c617_l1393_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c617_l1393_action_invoke"); + let result = instance.call("f32.load", &[Value::I32(36 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1394 +fn c618_l1394_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c618_l1394_action_invoke"); + let result = instance.call("f32.load", &[Value::I32(40 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1395 +fn c619_l1395_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c619_l1395_action_invoke"); + let result = instance.call("f32.load", &[Value::I32(44 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1397 + +#[test] +fn test_module_60() { + let mut instance = create_module_60(); + // We group the calls together + start_module_60(&mut instance); + c615_l1391_action_invoke(&mut instance); + c616_l1392_action_invoke(&mut instance); + c617_l1393_action_invoke(&mut instance); + c618_l1394_action_invoke(&mut instance); + c619_l1395_action_invoke(&mut instance); +} +fn create_module_61() -> Box { + let module_str = "(module + (type (;0;) (func (param i32 i32 i32))) + (type (;1;) (func (param i32) (result f64))) + (func (;0;) (type 0) (param i32 i32 i32) + (local f64 f64 f64 f64 f64 f64 f64 f64) + get_local 0 + f64.load + set_local 3 + get_local 0 + f64.load offset=8 + set_local 4 + get_local 0 + f64.load offset=16 + set_local 5 + get_local 0 + f64.load offset=24 + set_local 6 + get_local 1 + f64.load + set_local 7 + get_local 1 + f64.load offset=8 + set_local 8 + get_local 1 + f64.load offset=16 + set_local 9 + get_local 1 + f64.load offset=24 + set_local 10 + get_local 2 + get_local 3 + get_local 7 + f64.add + f64.store + get_local 2 + get_local 4 + get_local 8 + f64.add + f64.store offset=8 + get_local 2 + get_local 5 + get_local 9 + f64.add + f64.store offset=16 + get_local 2 + get_local 6 + get_local 10 + f64.add + f64.store offset=24) + (func (;1;) (type 1) (param i32) (result f64) + get_local 0 + f64.load) + (memory (;0;) 1 1) + (export \"f64.simple_x4_sum\" (func 0)) + (export \"f64.load\" (func 1)) + (data (;0;) (i32.const 0) \"\\01\\00\\00\\00\\00\\00\\00\\00\\01\\00\\00\\00\\00\\00\\00\\80\\01\\00\\00\\00\\00\\00\\00\\00\\01\\00\\00\\00\\00\\00\\00\\80\\01\\00\\00\\00\\00\\00\\00\\00\\01\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\")) + "; + 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_61(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 1430 +fn c621_l1430_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c621_l1430_action_invoke"); + let result = instance.call("f64.simple_x4_sum", &[Value::I32(0 as i32), Value::I32(32 as i32), Value::I32(64 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 1431 +fn c622_l1431_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c622_l1431_action_invoke"); + let result = instance.call("f64.load", &[Value::I32(64 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1432 +fn c623_l1432_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c623_l1432_action_invoke"); + let result = instance.call("f64.load", &[Value::I32(72 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1433 +fn c624_l1433_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c624_l1433_action_invoke"); + let result = instance.call("f64.load", &[Value::I32(80 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1434 +fn c625_l1434_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c625_l1434_action_invoke"); + let result = instance.call("f64.load", &[Value::I32(88 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1439 + +#[test] +fn test_module_61() { + let mut instance = create_module_61(); + // We group the calls together + start_module_61(&mut instance); + c621_l1430_action_invoke(&mut instance); + c622_l1431_action_invoke(&mut instance); + c623_l1432_action_invoke(&mut instance); + c624_l1433_action_invoke(&mut instance); + c625_l1434_action_invoke(&mut instance); +} +fn create_module_62() -> Box { + let module_str = "(module + (type (;0;) (func (param i32 i32) (result f32))) + (func (;0;) (type 0) (param i32 i32) (result f32) + (local f32 f32 f32) + block ;; label = @1 + loop ;; label = @2 + get_local 3 + get_local 0 + f32.load + get_local 4 + f32.sub + tee_local 4 + f32.add + tee_local 2 + get_local 3 + f32.sub + get_local 4 + f32.sub + set_local 4 + get_local 0 + i32.const 4 + i32.add + set_local 0 + get_local 2 + set_local 3 + get_local 1 + i32.const -1 + i32.add + tee_local 1 + br_if 0 (;@2;) + end + end + get_local 2) + (func (;1;) (type 0) (param i32 i32) (result f32) + (local f32) + block ;; label = @1 + loop ;; label = @2 + get_local 2 + get_local 0 + f32.load + f32.add + set_local 2 + get_local 0 + i32.const 4 + i32.add + set_local 0 + get_local 1 + i32.const -1 + i32.add + set_local 1 + get_local 1 + br_if 0 (;@2;) + end + end + get_local 2) + (memory (;0;) 1 1) + (export \"f32.kahan_sum\" (func 0)) + (export \"f32.plain_sum\" (func 1)) + (data (;0;) (i32.const 0) \"\\c4\\c5W$\\a5\\84\\c8\\0bm\\b8K.\\f2v\\17\\1c\\caJV\\1e\\1bnq\\22]\\17\\1en\\bf\\cd\\14\\5c\\c7!UQ9\\9c\\1f\\b2Q\\f0\\a3\\93\\d7\\c1,\\ae~\\a8(:\\01!\\f4\\0aX\\93\\f8Bw\\9f\\839j_\\ba\\f7\\0a\\d8Qj4\\ca\\ad\\c64\\0e\\d8&\\dcL3\\1c\\ed)\\90\\a8x\\0f\\d1\\cev1#\\83\\b85\\e8\\f2D\\b0\\d3\\a1\\fc\\bb2\\e1\\b0\\baiD\\09\\d6\\d9}\\ff.\\c0Z6\\143\\14>\\a9\\fa\\87m\\8b\\bc\\ce\\9d\\a7\\fd\\c4\\e9\\85?\\dd\\d7\\e1\\18\\a6P&rn?s\\0f\\f8\\12\\93#4av\\12H\\c0\\9b\\05\\93\\eb\\ac\\86\\de\\94>U\\e8\\8c\\e8\\dd\\e4\\fc\\95G\\beV\\03! L\\e6\\bf{\\f6\\7f\\d5\\bas\\1c\\c1\\14\\8f\\c4'\\96\\b3\\bd3\\ffxA_\\c0Z\\ce\\f6gns\\9a\\17fp\\03\\f8\\ce'\\a3R\\b2\\9f;\\bf\\fb\\ae\\ed\\d3Z\\f87W\\f0\\f5n\\ef\\b1Mp=T\\a7\\01\\9a\\85\\08H\\91\\f5\\9d\\0c`\\87[\\d9T\\1eQm\\88\\8e\\08\\8c\\a5q:V\\08gF\\8f\\8f\\13*,\\ec,\\1f\\b4b+oA\\0a\\c4eB\\a21k,}>\\bbu\\ac\\86\\970\\d9H\\cd\\9a\\1fV\\c4\\c6\\e4\\12\\c0\\9d\\fb\\ee\\02\\8c\\ce\\1c\\f2\\1e\\a1x#\\db\\c4\\1eI\\03\\d3q\\cc\\08P\\c5\\d8\\5c\\ed\\d5\\b5e\\ac\\b5\\c9!\\d2\\c9)v\\de\\f00\\1a[<\\f2;\\db:9\\82:\\16\\08o\\a8\\f1\\beii\\99q\\a6\\05\\d3\\14\\93*\\16\\f2/\\11\\c7~ \\bb\\91D\\ee\\f8\\e4\\01S\\c0\\b9\\7f\\f0\\bf\\f0\\03\\9cm\\b1\\df\\a2D\\01mkq+\\5c\\b3!\\19F^\\8f\\db\\91\\d3|xk\\b7\\12\\00\\8f\\eb\\bd\\8a\\f5\\d4.\\c4\\c1\\1e\\dfscYGI\\03\\0a\\b7\\cf$\\cf\\9c\\0eDz\\9e\\14\\fbB\\bf\\9d90\\9e\\a0\\ab/\\d1\\ae\\9ej\\83C\\e3U}\\85\\bfc\\8a\\f8\\96\\10\\1f\\fem\\e7\\22\\1b\\e1iF\\8aD\\c8\\c8\\f9\\0c+\\19\\07\\a5\\02>\\f20\\10\\9a\\85\\8a_\\ef\\81E\\a0w\\b1\\03\\10sK\\ae\\98\\9dG\\bf\\9a-:\\d5\\0f\\03f\\e3=S\\d9@\\ce\\1fo2/!+#!lb\\d4\\a7>\\a8\\ce(1-\\00=g^\\af\\a0\\cf.\\d2\\b9k\\84\\ebi\\08\\ad\\bc\\0b\\c0A\\c4P\\b6\\e3P1\\e8\\ce\\e2\\96eU\\9c\\16F\\e6\\b0-:\\e8\\81\\05\\b0\\bf4\\f7\\bc\\10\\1c\\fb\\cc<\\f1\\85\\97B\\9f\\eb\\14\\8d<\\bf\\d7\\17\\88I\\9d\\8b+\\b2:\\83\\d1O\\04\\9e\\a1\\0f\\ad\\08\\9dT\\af\\d1\\82\\c3\\ec2/\\02\\8f\\05!-\\a2\\b7\\e4\\f4o.\\81+\\0b\\9c\\fc\\cb\\fet\\02\\f9\\db\\f4\\f3\\ea\\00\\a8\\ec\\d1\\99t&\\dd\\d64\\d5%\\b1F\\dd\\9c\\aaq\\f5`\\b0\\88\\c8\\e0\\0bYZ%O)f\\f9\\e3.\\fe\\e9\\da\\e5\\18O'b\\f4\\ce\\a4!\\95t\\c7Wd'\\9aL\\fdT}a\\ce\\c3\\ac\\87F\\9c\\fa\\ff\\09\\cay\\97g$t\\ca\\d4!\\83&%\\19\\127d\\19\\e5e\\e0tu\\8e\\dd\\c8\\eft\\c7\\d8!+y\\04QFe`\\03]\\fa\\d8\\f4e\\a4\\9e]#\\da\\d7\\8a\\92\\80\\a4\\dex<\\f1WBm\\cd\\c9/\\d5\\a4\\9e\\ab@\\f4\\cb\\1b\\d7\\a3\\ca\\fc\\eb\\a7\\01\\b2\\9aiNF\\9b\\18N\\ddy\\a7\\aa\\a6R9\\1e\\ef0\\cc\\9b\\bd[\\eeL!m0\\00r\\b0F_\\08\\cf\\c5\\b9\\e0>\\c2\\b3\\0c\\dc\\8ed\\de\\19By\\cfC\\eaC]\\8e\\88\\f7\\ab\\15\\dc?\\c8g \\db\\b8d\\b1G\\1f\\de\\f2\\cb?Y\\9f\\d8F\\90\\dc\\ae/\\22\\f9\\e21\\89\\d9\\9c\\1cL\\d3\\a9JW\\84\\9c\\9f\\ea,<\\ae<\\c3\\1e\\8b\\e5N\\17\\01%\\db4F_\\15\\ea\\05\\0c|\\d9E\\8c\\19\\d0s\\8a\\96\\16\\ddD\\f9\\05\\b7[q\\b0\\e6!6_u\\89\\91su\\ab}\\ae\\d3s\\ec7\\c6\\eaUu\\ef\\ea\\ab\\8b{\\11\\dcm\\1a\\b2j\\c4%\\cf\\aa\\e3\\9fII\\89\\cb7\\9b\\0a\\a7\\01`p\\dc\\b7\\c8\\83\\e1B\\f5\\be\\adb\\94\\ad\\8d\\a1\")) + "; + 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_62(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 1530 +fn c627_l1530_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c627_l1530_action_invoke"); + let result = instance.call("f32.kahan_sum", &[Value::I32(0 as i32), Value::I32(256 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((-21558138000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1531 +fn c628_l1531_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c628_l1531_action_invoke"); + let result = instance.call("f32.plain_sum", &[Value::I32(0 as i32), Value::I32(256 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((-16487540000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1533 + +#[test] +fn test_module_62() { + let mut instance = create_module_62(); + // We group the calls together + start_module_62(&mut instance); + c627_l1530_action_invoke(&mut instance); + c628_l1531_action_invoke(&mut instance); +} +fn create_module_63() -> Box { + let module_str = "(module + (type (;0;) (func (param i32 i32) (result f64))) + (func (;0;) (type 0) (param i32 i32) (result f64) + (local f64 f64 f64) + block ;; label = @1 + loop ;; label = @2 + get_local 3 + get_local 0 + f64.load + get_local 4 + f64.sub + tee_local 4 + f64.add + tee_local 2 + get_local 3 + f64.sub + get_local 4 + f64.sub + set_local 4 + get_local 0 + i32.const 8 + i32.add + set_local 0 + get_local 2 + set_local 3 + get_local 1 + i32.const -1 + i32.add + tee_local 1 + br_if 0 (;@2;) + end + end + get_local 2) + (func (;1;) (type 0) (param i32 i32) (result f64) + (local f64) + block ;; label = @1 + loop ;; label = @2 + get_local 2 + get_local 0 + f64.load + f64.add + set_local 2 + get_local 0 + i32.const 8 + i32.add + set_local 0 + get_local 1 + i32.const -1 + i32.add + set_local 1 + get_local 1 + br_if 0 (;@2;) + end + end + get_local 2) + (memory (;0;) 1 1) + (export \"f64.kahan_sum\" (func 0)) + (export \"f64.plain_sum\" (func 1)) + (data (;0;) (i32.const 0) \"\\13\\05\\84B]\\a2,\\c6C\\dbU\\a9\\cd\\daU\\e3s\\fcX\\d6\\ba\\d5\\00\\fd\\835B\\88\\8b\\13]8JG\\0drs\\a1\\1a\\ef\\c4E\\17W\\d8\\c9F\\e0\\8dl\\e17p\\c8\\83[U^Z-s\\1eV\\c8\\e1mi\\14x\\0a\\8aZd:\\09\\c7\\a8\\87\\c5\\f0\\d3]\\e6\\03\\fc\\93\\be&\\ca\\d6\\a9\\91`\\bd\\b0\\ed\\ae\\f70~\\92:o\\a7Y\\8e\\aa}\\bfgX*T\\f8N\\fe\\ed5X\\a6Q\\bfB\\e5Kf'$m\\7fB-(\\92\\18\\ec\\08\\ae\\e7U\\da\\b1\\a6e\\a5rPG\\1b\\b8\\a9T\\d7\\a6\\06[\\0fBX\\83\\8a\\17\\82\\c6\\10C\\a0\\c0.m\\bcZ\\85Sr\\7f\\adD\\bc0I\\f2~H\\f4\\a2q\\d0\\13\\8e\\b3\\de\\99R\\e3Et\\eav\\0e\\1b*\\c8\\ee\\14\\01\\c4P[6<\\ef\\bar\\a2\\a6\\08\\f8{6\\9d\\f9\\ef\\0b\\c7V-\\5c\\f0\\9d]\\de\\fc\\b8\\ad\\0fd\\0e\\97\\152&\\c21\\e6\\05\\1e\\ef\\cb\\17\\1bm\\15\\0bt]\\d3.\\f8k\\86\\b4\\basRS\\99\\a9v E\\c9@\\80k\\14\\ed\\a1\\fa\\80F\\e6&\\d2\\e6\\98\\c4W\\bf\\c4\\1c\\a4\\90z6\\94\\14\\ba\\15\\89n\\e6\\9c7\\8c\\f4\\de\\12\\22]\\a1yPg\\0d=z\\e9\\d4\\aa.\\7f*z0=\\ea]\\12H\\fe\\e1\\18\\cd\\a4W\\a2\\87>\\b6\\9a\\8b\\db\\da\\9dx\\9c\\cf\\8d\\b1O\\90\\b44\\e0\\9d\\f6\\ca\\feL;xm\\0a\\5c\\18\\9fa\\b9\\dd\\b4\\e0\\0fv\\e0\\1bi\\0d^Xsp^\\0e-\\a1}\\ff \\eb\\914\\92\\ac8r*\\1f\\8eq.j\\f1\\af\\c7'p\\d9\\c4W\\f7\\d2<\\1d\\b8\\f0\\f0d\\cf\\dc\\ae\\be\\a3\\cc>\\22}Ni!c\\17\\ed\\03\\02T\\9a\\0fPN\\13Z5\\a1\\22\\a4\\df\\86\\c2ty\\16\\b8ii\\a0R]\\11d\\bd[\\93\\fci\\a0\\f4\\13\\d0\\81Q\\dd\\fa\\0c\\15\\c3z\\c9bz\\a9\\1d\\c9\\e6Z\\b3[\\97\\02\\d0\\c4\\8d4\\19P!\\0a\\bcP\\da<0\\d6:1\\94\\8d:\\fe\\ef\\14W\\9dK\\93\\00\\96$\\0co\\fd\\bc#v\\02l\\ebRr\\80\\11~\\80:\\13\\128\\1d8I\\95@'\\8aD{\\e8\\dcm\\8c\\8c\\8e<\\b5\\b3\\18\\0e\\f6\\08\\1a\\84A5\\ff\\8b\\b8\\93@\\ea\\e1Q\\1d\\89\\a5\\8dBh)\\ea/\\c1zR\\eb\\90]M\\d6\\80\\e3\\d7uH\\ce\\ed\\d3\\01\\1c\\8d[\\a5\\94\\0dx\\cf\\f1\\06\\13/\\98\\02\\a4m.l\\f2\\d5t)\\89L\\f9\\03\\f5\\c7\\18\\adz\\f0h\\f8\\5c\\d6Y\\87n\\d6?\\06\\be\\86 \\e3A\\91\\22\\f3n\\8b\\f0h\\1cW\\a7\\fc\\b0|\\9e\\99\\0b\\96\\1a\\89_\\e6\\0d|\\08Q\\a0\\a2g\\9aG\\00\\93k\\f9(\\f0h\\dbb\\f1\\e0e,S3\\e0\\a7\\ca\\11B0\\f6\\af\\01\\c1e=2\\01o\\ab.\\be\\d3\\8b\\be\\14\\c3\\ff\\ec\\fb\\f0\\f9\\c5\\0c\\05o\\01\\09k\\e341\\0c\\1ff\\a6B\\bc\\1a\\87I\\16\\16\\8c\\b0\\90\\0d4\\8c\\0a\\e1\\09^\\10\\a4kV\\cc\\f0\\c9\\bb\\dc\\b8\\5c\\ce\\f6\\cc\\8du~\\b3\\07\\88\\04/\\b4^\\c9\\e3J#s\\19bl\\9a\\03vD\\86\\9c`\\fc\\dbr\\8f'\\a0\\dd\\b3\\c5\\da\\ff\\f9\\ecj\\b1{\\d3\\cfP7\\c9zx\\0c\\e4:\\b6\\f5\\e6\\f4\\98nB}5s\\8bE\\c0V\\97\\cdm\\ce\\cf\\ad1\\b3\\c3T\\fa\\ef\\d5\\c0\\f4j_T\\e7I>3\\0a08\\fd\\d9\\05\\ff\\a5?WF\\14\\b5\\91\\17\\cak\\98#ze\\b3l\\02\\b4\\ccy]X\\d8\\b3\\d5\\94\\ae\\f4mue\\f7\\92\\bf~GL<\\ee\\db\\ac\\f12]\\fboA\\1c4\\c8\\83O\\c2X\\01\\be\\05>f\\16\\a6\\04m]O\\86\\09'\\82%\\12\\cd:\\cd\\cek\\bc\\ca\\ac(\\9b\\eej%\\86\\9eEp\\c6\\d2\\bd;}B\\e5'\\af\\c7\\1d\\f4\\81\\c8\\b3v\\8a\\a86\\a3\\ae*\\e6\\18\\e16\\22\\ad\\f6%r\\b09\\8b\\01\\9a\\22{\\84\\c3-_r\\a4\\98\\ac\\15p\\e7\\d4\\18\\e2}\\d20|3\\08\\cd\\ca\\c4\\22\\85\\88u\\81\\c6JtX\\8d\\e0\\e8\\ac\\c5\\abuZ\\f4(\\12\\f0\\18ER\\f2\\97\\b2\\93Ao\\8d\\7f\\dbp\\fb\\a3]\\1f\\a7\\8d\\98 +\\22\\9f:\\01\\b5\\8b\\1b\\d2\\cb\\14\\03\\0e\\14\\14\\d2\\19Z\\1f\\ce^\\cd\\81y\\15\\01\\ca\\dest\\8cV \\9fw-%\\16\\f6aQ\\1d\\a4\\8e\\9b\\98\\a5\\c6\\ec\\a8EW\\82Yx\\0d\\90\\b4\\dfQ\\b0\\c3\\82\\94\\cc\\b3S\\09\\15m\\96l:@G\\b7Jz\\05/\\a1\\1e\\8c\\9d\\a0 \\88\\fbR\\b7\\9f\\f3\\f3\\bb_\\e7\\8aa\\a7!\\b1\\ac\\fa\\09\\aa\\a4l\\bc$\\80\\ba*\\e9e\\ffp\\ff\\cc\\fae\\87v\\f3\\c5\\15\\ce\\cb\\e8B1\\00\\0c\\91W\\d9\\e0\\9d5T$\\ad\\a4\\d8\\f9\\08gc\\c8\\cf\\81\\dd\\90\\a2\\d7\\c4\\07J\\e6\\10og\\e7'\\d4#Y\\18\\f2\\a8\\9d_\\d8\\940\\aaT\\86O\\87\\9d\\82\\b5&\\ca\\a6\\96\\bf\\cfU\\f9\\9d7\\01\\19HC\\c5\\94l\\f3t\\97XL<\\9d\\08\\e8\\04\\c2X0v\\e1\\a0\\f8\\ea\\e9\\c5\\ae\\cfx\\9e\\a9\\0c\\ac\\b3DB\\e0\\bc]\\1b\\9cIXJ\\1c\\19I\\c1:\\ea\\f5\\eb;\\81\\a9Kp\\0c\\cc\\9e\\1a\\d3/\\b7R/ ;\\ebdQ\\1d\\a0-\\b2>\\be\\13\\85H\\922.\\db\\5c\\a1\\e7\\8cE\\915\\01\\0a\\93\\c2\\eb\\09\\ce\\f3\\d2\\22$\\d0\\8c\\cc\\1d\\9d8\\c8M\\e3\\82\\ccd\\15\\06-\\e7\\01/\\ab\\bb\\b5\\04L\\92\\1cz\\d6?\\e8_1\\15\\0c\\dc\\e41\\b4\\c4%>*\\aa\\00\\9e\\c8\\e5!z\\7f)\\f1\\c0\\af\\1d^\\e8c9\\ad\\f8~l\\c8\\c5\\7f\\c2\\a8\\97'\\0a\\d9\\f4!j\\ea\\03\\09\\fb\\f7\\96;\\83y_|K0\\9fV5\\de\\b4s\\d4\\95\\f0\\14\\c3t/\\0d\\a3\\1dN\\8d1$\\b3\\1a\\84\\85bZ{<\\149\\17\\e6m\\eb7\\c2\\00X[\\0b\\e3<\\8ab\\e1\\f85KV\\e2\\87`\\8b\\be\\a78\\91wT\\a9Z$%\\90\\9f\\a5Bw\\f3\\5c9\\df\\fft\\07v\\a1\\cd\\1fb\\0b\\81\\81h\\af\\05\\c1\\c0\\7f&\\ee\\c0\\91\\a3j})aE'\\e5W\\88\\dc\\0d\\97\\04\\1a3\\a9D\\8a\\da\\02\\10E?\\8eU\\a6v\\8cM\\e3\\f1\\89\\83\\c8\\d0\\f8\\9bPw\\9fG\\dfL\\9cf\\0d\\aa\\18\\b8_O\\c4\\01\\ce\\dc\\84\\acF\\9ei\\e1vEka\\89\\e4]\\94\\bb\\11\\83\\9fx\\d8\\0a\\d2\\f5~]C\\ea\\bc\\10\\f1:\\c9\\e2d\\fbSe\\d0\\c7\\b4\\a7\\fb\\d4\\05S%\\d0\\cd)\\88\\00V%$}]\\b4\\f3A\\9f\\e9\\b5\\f7\\aed,\\e3\\c9m\\d5\\84:r\\12\\b8z\\d9\\1b\\09\\e88\\da&O\\04\\ce\\03qn\\8aD{\\5c\\81Y\\9c\\d2\\e4\\c3\\baY\\a6\\e5(\\a7\\8f\\9a\\e4\\d5N\\b9\\ca\\7f\\cbu\\b8+C>\\b3\\15F\\b1\\a5\\bc\\9d\\9e8\\15\\f1\\bd\\1b!\\aa\\f1\\82\\00\\95\\fc\\a7wG9\\a73C\\92\\d7R@K\\06\\81\\8a\\a0\\bd\\f1k\\99\\84B[\\e2;\\c5^\\12\\5c(M\\b6\\0eN\\c8\\5c\\e8\\01\\8a\\c5\\e7\\e4\\9dB\\ee]\\9c\\c4\\eb\\ebh\\09'\\92\\95\\9a\\11Ts\\c4\\12\\80\\fb}\\fe\\c5\\08`\\7f6A\\e0\\10\\ba\\d6+l\\f1\\b4\\17\\fe&4\\e3K\\f8\\a8\\e3\\91\\beO*\\fc\\da\\81\\b8\\e7\\fe\\d5&PG\\f3\\1ae2\\81\\e0\\05\\b8O21&\\00JS\\97\\c2\\c3\\0e.\\a1&T\\ab\\05\\8eV/}\\af\\22\\84h\\a5\\8b\\97\\f6\\a4\\fd\\a8\\ccuA\\96\\86\\fd'=)\\86\\8d\\7fL\\d4\\8esA\\f4\\1e\\e2\\ddX'\\97\\ce\\9c\\94\\cfz\\04/\\dc\\ed\")) + "; + 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_63(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 1581 +fn c630_l1581_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c630_l1581_action_invoke"); + let result = instance.call("f64.kahan_sum", &[Value::I32(0 as i32), Value::I32(256 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((4996401743142033000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1582 +fn c631_l1582_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c631_l1582_action_invoke"); + let result = instance.call("f64.plain_sum", &[Value::I32(0 as i32), Value::I32(256 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((4996401743297957600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1586 + +#[test] +fn test_module_63() { + let mut instance = create_module_63(); + // We group the calls together + start_module_63(&mut instance); + c630_l1581_action_invoke(&mut instance); + c631_l1582_action_invoke(&mut instance); +} +fn create_module_64() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32) (result f32))) + (type (;1;) (func (param f64 f64) (result f64))) + (func (;0;) (type 0) (param f32 f32) (result f32) + get_local 0 + get_local 1 + f32.sub + f32.neg) + (func (;1;) (type 1) (param f64 f64) (result f64) + get_local 0 + get_local 1 + f64.sub + f64.neg) + (export \"f32.no_fold_neg_sub\" (func 0)) + (export \"f64.no_fold_neg_sub\" (func 1))) + "; + 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_64(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 1594 +fn c633_l1594_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c633_l1594_action_invoke"); + let result = instance.call("f32.no_fold_neg_sub", &[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 1595 +fn c634_l1595_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c634_l1595_action_invoke"); + let result = instance.call("f32.no_fold_neg_sub", &[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 1596 +fn c635_l1596_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c635_l1596_action_invoke"); + let result = instance.call("f32.no_fold_neg_sub", &[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 1597 +fn c636_l1597_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c636_l1597_action_invoke"); + let result = instance.call("f32.no_fold_neg_sub", &[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 1599 +fn c637_l1599_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c637_l1599_action_invoke"); + let result = instance.call("f64.no_fold_neg_sub", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1600 +fn c638_l1600_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c638_l1600_action_invoke"); + let result = instance.call("f64.no_fold_neg_sub", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1601 +fn c639_l1601_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c639_l1601_action_invoke"); + let result = instance.call("f64.no_fold_neg_sub", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1602 +fn c640_l1602_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c640_l1602_action_invoke"); + let result = instance.call("f64.no_fold_neg_sub", &[Value::F64((0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1606 + +#[test] +fn test_module_64() { + let mut instance = create_module_64(); + // We group the calls together + start_module_64(&mut instance); + c633_l1594_action_invoke(&mut instance); + c634_l1595_action_invoke(&mut instance); + c635_l1596_action_invoke(&mut instance); + c636_l1597_action_invoke(&mut instance); + c637_l1599_action_invoke(&mut instance); + c638_l1600_action_invoke(&mut instance); + c639_l1601_action_invoke(&mut instance); + c640_l1602_action_invoke(&mut instance); +} +fn create_module_65() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32) (result f32))) + (type (;1;) (func (param f64 f64) (result f64))) + (func (;0;) (type 0) (param f32 f32) (result f32) + get_local 0 + get_local 1 + f32.add + f32.neg) + (func (;1;) (type 1) (param f64 f64) (result f64) + get_local 0 + get_local 1 + f64.add + f64.neg) + (export \"f32.no_fold_neg_add\" (func 0)) + (export \"f64.no_fold_neg_add\" (func 1))) + "; + 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_65(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 1614 +fn c642_l1614_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c642_l1614_action_invoke"); + let result = instance.call("f32.no_fold_neg_add", &[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 1615 +fn c643_l1615_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c643_l1615_action_invoke"); + let result = instance.call("f32.no_fold_neg_add", &[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 1616 +fn c644_l1616_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c644_l1616_action_invoke"); + let result = instance.call("f32.no_fold_neg_add", &[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 1617 +fn c645_l1617_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c645_l1617_action_invoke"); + let result = instance.call("f32.no_fold_neg_add", &[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 1619 +fn c646_l1619_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c646_l1619_action_invoke"); + let result = instance.call("f64.no_fold_neg_add", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1620 +fn c647_l1620_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c647_l1620_action_invoke"); + let result = instance.call("f64.no_fold_neg_add", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1621 +fn c648_l1621_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c648_l1621_action_invoke"); + let result = instance.call("f64.no_fold_neg_add", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1622 +fn c649_l1622_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c649_l1622_action_invoke"); + let result = instance.call("f64.no_fold_neg_add", &[Value::F64((0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1626 + +#[test] +fn test_module_65() { + let mut instance = create_module_65(); + // We group the calls together + start_module_65(&mut instance); + c642_l1614_action_invoke(&mut instance); + c643_l1615_action_invoke(&mut instance); + c644_l1616_action_invoke(&mut instance); + c645_l1617_action_invoke(&mut instance); + c646_l1619_action_invoke(&mut instance); + c647_l1620_action_invoke(&mut instance); + c648_l1621_action_invoke(&mut instance); + c649_l1622_action_invoke(&mut instance); +} +fn create_module_66() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32) (result f32))) + (type (;1;) (func (param f64 f64) (result f64))) + (func (;0;) (type 0) (param f32 f32) (result f32) + get_local 0 + f32.neg + get_local 1 + f32.neg + f32.add) + (func (;1;) (type 1) (param f64 f64) (result f64) + get_local 0 + f64.neg + get_local 1 + f64.neg + f64.add) + (export \"f32.no_fold_add_neg_neg\" (func 0)) + (export \"f64.no_fold_add_neg_neg\" (func 1))) + "; + 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_66(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 1634 +fn c651_l1634_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c651_l1634_action_invoke"); + let result = instance.call("f32.no_fold_add_neg_neg", &[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 1635 +fn c652_l1635_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c652_l1635_action_invoke"); + let result = instance.call("f32.no_fold_add_neg_neg", &[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 1636 +fn c653_l1636_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c653_l1636_action_invoke"); + let result = instance.call("f32.no_fold_add_neg_neg", &[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 1637 +fn c654_l1637_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c654_l1637_action_invoke"); + let result = instance.call("f32.no_fold_add_neg_neg", &[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 1639 +fn c655_l1639_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c655_l1639_action_invoke"); + let result = instance.call("f64.no_fold_add_neg_neg", &[Value::F64((-0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1640 +fn c656_l1640_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c656_l1640_action_invoke"); + let result = instance.call("f64.no_fold_add_neg_neg", &[Value::F64((0.0f64).to_bits()), Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1641 +fn c657_l1641_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c657_l1641_action_invoke"); + let result = instance.call("f64.no_fold_add_neg_neg", &[Value::F64((-0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1642 +fn c658_l1642_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c658_l1642_action_invoke"); + let result = instance.call("f64.no_fold_add_neg_neg", &[Value::F64((0.0f64).to_bits()), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1646 + +#[test] +fn test_module_66() { + let mut instance = create_module_66(); + // We group the calls together + start_module_66(&mut instance); + c651_l1634_action_invoke(&mut instance); + c652_l1635_action_invoke(&mut instance); + c653_l1636_action_invoke(&mut instance); + c654_l1637_action_invoke(&mut instance); + c655_l1639_action_invoke(&mut instance); + c656_l1640_action_invoke(&mut instance); + c657_l1641_action_invoke(&mut instance); + c658_l1642_action_invoke(&mut instance); +} +fn create_module_67() -> Box { + let module_str = "(module + (type (;0;) (func (param f32) (result f32))) + (type (;1;) (func (param f64) (result f64))) + (func (;0;) (type 0) (param f32) (result f32) + get_local 0 + f32.neg + get_local 0 + f32.add) + (func (;1;) (type 1) (param f64) (result f64) + get_local 0 + f64.neg + get_local 0 + f64.add) + (export \"f32.no_fold_add_neg\" (func 0)) + (export \"f64.no_fold_add_neg\" (func 1))) + "; + 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_67(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 1654 +fn c660_l1654_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c660_l1654_action_invoke"); + let result = instance.call("f32.no_fold_add_neg", &[Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1655 +fn c661_l1655_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c661_l1655_action_invoke"); + let result = instance.call("f32.no_fold_add_neg", &[Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1656 +fn c662_l1656_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c662_l1656_assert_return_canonical_nan"); + let result = instance.call("f32.no_fold_add_neg", &[Value::F32(f32::INFINITY.to_bits())]).unwrap().expect("Missing result in c662_l1656_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1657 +fn c663_l1657_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c663_l1657_assert_return_canonical_nan"); + let result = instance.call("f32.no_fold_add_neg", &[Value::F32(f32::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c663_l1657_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1659 +fn c664_l1659_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c664_l1659_action_invoke"); + let result = instance.call("f64.no_fold_add_neg", &[Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1660 +fn c665_l1660_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c665_l1660_action_invoke"); + let result = instance.call("f64.no_fold_add_neg", &[Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1661 +fn c666_l1661_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c666_l1661_assert_return_canonical_nan"); + let result = instance.call("f64.no_fold_add_neg", &[Value::F64(f64::INFINITY.to_bits())]).unwrap().expect("Missing result in c666_l1661_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1662 +fn c667_l1662_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c667_l1662_assert_return_canonical_nan"); + let result = instance.call("f64.no_fold_add_neg", &[Value::F64(f64::NEG_INFINITY.to_bits())]).unwrap().expect("Missing result in c667_l1662_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1666 + +#[test] +fn test_module_67() { + let mut instance = create_module_67(); + // We group the calls together + start_module_67(&mut instance); + c660_l1654_action_invoke(&mut instance); + c661_l1655_action_invoke(&mut instance); + c662_l1656_assert_return_canonical_nan(&mut instance); + c663_l1657_assert_return_canonical_nan(&mut instance); + c664_l1659_action_invoke(&mut instance); + c665_l1660_action_invoke(&mut instance); + c666_l1661_assert_return_canonical_nan(&mut instance); + c667_l1662_assert_return_canonical_nan(&mut instance); +} +fn create_module_68() -> Box { + let module_str = "(module + (type (;0;) (func (param f32) (result f32))) + (type (;1;) (func (param f64) (result f64))) + (func (;0;) (type 0) (param f32) (result f32) + get_local 0 + get_local 0 + f32.add + get_local 0 + f32.add + get_local 0 + f32.add + get_local 0 + f32.add + get_local 0 + f32.add) + (func (;1;) (type 1) (param f64) (result f64) + get_local 0 + get_local 0 + f64.add + get_local 0 + f64.add + get_local 0 + f64.add + get_local 0 + f64.add + get_local 0 + f64.add) + (export \"f32.no_fold_6x_via_add\" (func 0)) + (export \"f64.no_fold_6x_via_add\" (func 1))) + "; + 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_68(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 1680 +fn c669_l1680_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c669_l1680_action_invoke"); + let result = instance.call("f32.no_fold_6x_via_add", &[Value::F32((-855513700000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-5133083000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1681 +fn c670_l1681_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c670_l1681_action_invoke"); + let result = instance.call("f32.no_fold_6x_via_add", &[Value::F32((-0.00000000000000000000001209506f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000000007257036f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1682 +fn c671_l1682_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c671_l1682_action_invoke"); + let result = instance.call("f32.no_fold_6x_via_add", &[Value::F32((0.000000000000000000000006642689f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000039856134f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1683 +fn c672_l1683_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c672_l1683_action_invoke"); + let result = instance.call("f32.no_fold_6x_via_add", &[Value::F32((-0.0000000006147346f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0000000036884074f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1684 +fn c673_l1684_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c673_l1684_action_invoke"); + let result = instance.call("f32.no_fold_6x_via_add", &[Value::F32((-1209858100000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-7259148300000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1686 +fn c674_l1686_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c674_l1686_action_invoke"); + let result = instance.call("f64.no_fold_6x_via_add", &[Value::F64((-351704490602771400000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-2110226943616628600000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1687 +fn c675_l1687_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c675_l1687_action_invoke"); + let result = instance.call("f64.no_fold_6x_via_add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014824294109868734f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008894576465921239f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1688 +fn c676_l1688_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c676_l1688_action_invoke"); + let result = instance.call("f64.no_fold_6x_via_add", &[Value::F64((-7484567838781003000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-44907407032686014000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1689 +fn c677_l1689_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c677_l1689_action_invoke"); + let result = instance.call("f64.no_fold_6x_via_add", &[Value::F64((17277868192936067000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((103667209157616410000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1690 +fn c678_l1690_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c678_l1690_action_invoke"); + let result = instance.call("f64.no_fold_6x_via_add", &[Value::F64((-43116397525195610000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-258698385151173640000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1695 + +#[test] +fn test_module_68() { + let mut instance = create_module_68(); + // We group the calls together + start_module_68(&mut instance); + c669_l1680_action_invoke(&mut instance); + c670_l1681_action_invoke(&mut instance); + c671_l1682_action_invoke(&mut instance); + c672_l1683_action_invoke(&mut instance); + c673_l1684_action_invoke(&mut instance); + c674_l1686_action_invoke(&mut instance); + c675_l1687_action_invoke(&mut instance); + c676_l1688_action_invoke(&mut instance); + c677_l1689_action_invoke(&mut instance); + c678_l1690_action_invoke(&mut instance); +} +fn create_module_69() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32 f32) (result f32))) + (type (;1;) (func (param f64 f64 f64) (result f64))) + (func (;0;) (type 0) (param f32 f32 f32) (result f32) + get_local 0 + get_local 1 + f32.div + get_local 2 + f32.div) + (func (;1;) (type 1) (param f64 f64 f64) (result f64) + get_local 0 + get_local 1 + f64.div + get_local 2 + f64.div) + (export \"f32.no_fold_div_div\" (func 0)) + (export \"f64.no_fold_div_div\" (func 1))) + "; + 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_69(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 1703 +fn c680_l1703_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c680_l1703_action_invoke"); + let result = instance.call("f32.no_fold_div_div", &[Value::F32((-593847530000000000000000.0f32).to_bits()), Value::F32((-0.000030265672f32).to_bits()), Value::F32((-1584.8682f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-12380309000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1704 +fn c681_l1704_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c681_l1704_action_invoke"); + let result = instance.call("f32.no_fold_div_div", &[Value::F32((0.0000000000000000000015438962f32).to_bits()), Value::F32((2533429300000000000000000000000000.0f32).to_bits()), Value::F32((-0.00000000000000000000000000000000026844783f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1705 +fn c682_l1705_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c682_l1705_action_invoke"); + let result = instance.call("f32.no_fold_div_div", &[Value::F32((13417423000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000029339205f32).to_bits()), Value::F32((76386374000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1706 +fn c683_l1706_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c683_l1706_action_invoke"); + let result = instance.call("f32.no_fold_div_div", &[Value::F32((-0.00010776529f32).to_bits()), Value::F32((-34220943000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.00000000000016562324f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000019011327f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1707 +fn c684_l1707_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c684_l1707_action_invoke"); + let result = instance.call("f32.no_fold_div_div", &[Value::F32((130582500000000.0f32).to_bits()), Value::F32((96245350000000000.0f32).to_bits()), Value::F32((-41461545000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000032723f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1709 +fn c685_l1709_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c685_l1709_action_invoke"); + let result = instance.call("f64.no_fold_div_div", &[Value::F64((477762874671014340000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((102786720420404010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000718999894988884f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-64646730118787990000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1710 +fn c686_l1710_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c686_l1710_action_invoke"); + let result = instance.call("f64.no_fold_div_div", &[Value::F64((-21790236783875714000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.0000000028324436844616576f64).to_bits()), Value::F64((186110768259868700000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-41336068079920670000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1711 +fn c687_l1711_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c687_l1711_action_invoke"); + let result = instance.call("f64.no_fold_div_div", &[Value::F64((-7.287619347826683f64).to_bits()), Value::F64((-13467607316739855000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((2462719007013688000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000219725454f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1712 +fn c688_l1712_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c688_l1712_action_invoke"); + let result = instance.call("f64.no_fold_div_div", &[Value::F64((-286552397862963300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010211980370639414f64).to_bits()), Value::F64((28764586483324010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1713 +fn c689_l1713_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c689_l1713_action_invoke"); + let result = instance.call("f64.no_fold_div_div", &[Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009525735602663874f64).to_bits()), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000050233948816631796f64).to_bits()), Value::F64((-0.0000000000000000000000000000000000000000028304570228221077f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000006699534674970116f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1719 + +#[test] +fn test_module_69() { + let mut instance = create_module_69(); + // We group the calls together + start_module_69(&mut instance); + c680_l1703_action_invoke(&mut instance); + c681_l1704_action_invoke(&mut instance); + c682_l1705_action_invoke(&mut instance); + c683_l1706_action_invoke(&mut instance); + c684_l1707_action_invoke(&mut instance); + c685_l1709_action_invoke(&mut instance); + c686_l1710_action_invoke(&mut instance); + c687_l1711_action_invoke(&mut instance); + c688_l1712_action_invoke(&mut instance); + c689_l1713_action_invoke(&mut instance); +} +fn create_module_70() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32 f32 f32) (result f32))) + (type (;1;) (func (param f64 f64 f64 f64) (result f64))) + (func (;0;) (type 0) (param f32 f32 f32 f32) (result f32) + get_local 0 + get_local 1 + f32.div + get_local 2 + get_local 3 + f32.div + f32.mul) + (func (;1;) (type 1) (param f64 f64 f64 f64) (result f64) + get_local 0 + get_local 1 + f64.div + get_local 2 + get_local 3 + f64.div + f64.mul) + (export \"f32.no_fold_mul_divs\" (func 0)) + (export \"f64.no_fold_mul_divs\" (func 1))) + "; + 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_70(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 1727 +fn c691_l1727_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c691_l1727_action_invoke"); + let result = instance.call("f32.no_fold_mul_divs", &[Value::F32((-0.0000000000000000000000000000000027234733f32).to_bits()), Value::F32((0.0000000000000000000000000003897843f32).to_bits()), Value::F32((0.000000000000000000000000004847123f32).to_bits()), Value::F32((-25.357775f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000000000000000013355855f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1728 +fn c692_l1728_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c692_l1728_action_invoke"); + let result = instance.call("f32.no_fold_mul_divs", &[Value::F32((-5372844000000000000000000000000.0f32).to_bits()), Value::F32((38340910.0f32).to_bits()), Value::F32((0.000014973162f32).to_bits()), Value::F32((0.19213825f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-10920475000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1729 +fn c693_l1729_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c693_l1729_action_invoke"); + let result = instance.call("f32.no_fold_mul_divs", &[Value::F32((-16085042000.0f32).to_bits()), Value::F32((-1092920200000.0f32).to_bits()), Value::F32((-869606000.0f32).to_bits()), Value::F32((-1201.206f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((10654.639f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1730 +fn c694_l1730_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c694_l1730_action_invoke"); + let result = instance.call("f32.no_fold_mul_divs", &[Value::F32((-1271223140000000000000000000000000.0f32).to_bits()), Value::F32((0.00000000010768114f32).to_bits()), Value::F32((0.000018576271f32).to_bits()), Value::F32((492686200000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1731 +fn c695_l1731_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c695_l1731_action_invoke"); + let result = instance.call("f32.no_fold_mul_divs", &[Value::F32((0.00000000000000013783864f32).to_bits()), Value::F32((-0.000000000000000000065046285f32).to_bits()), Value::F32((0.00000000000000000000000000068167684f32).to_bits()), Value::F32((0.000000000022892627f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000063100295f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1733 +fn c696_l1733_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c696_l1733_action_invoke"); + let result = instance.call("f64.no_fold_mul_divs", &[Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003466499805233369f64).to_bits()), Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004045567512248635f64).to_bits()), Value::F64((-646234107060759200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((100455895333540740000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-55.12215321310017f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1734 +fn c697_l1734_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c697_l1734_action_invoke"); + let result = instance.call("f64.no_fold_mul_divs", &[Value::F64((-50548839076363250000000000000000000.0f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022223781649976275f64).to_bits()), Value::F64((-15029790371100852000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-699412375953812100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1735 +fn c698_l1735_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c698_l1735_action_invoke"); + let result = instance.call("f64.no_fold_mul_divs", &[Value::F64((-836111653634494700000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-10029528876067567000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.0000000000000000000000000000000000000000012867801766038772f64).to_bits()), Value::F64((-42230277746883753000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002540178100556387f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1736 +fn c699_l1736_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c699_l1736_action_invoke"); + let result = instance.call("f64.no_fold_mul_divs", &[Value::F64((-1202003211641119300000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004667409771338769f64).to_bits()), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010888652376540085f64).to_bits()), Value::F64((18334948666517216000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1737 +fn c700_l1737_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c700_l1737_action_invoke"); + let result = instance.call("f64.no_fold_mul_divs", &[Value::F64((0.000006331839568840419f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000005544474241905778f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000027822472480359097f64).to_bits()), Value::F64((-14419321081893022000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022035374770746518f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1741 + +#[test] +fn test_module_70() { + let mut instance = create_module_70(); + // We group the calls together + start_module_70(&mut instance); + c691_l1727_action_invoke(&mut instance); + c692_l1728_action_invoke(&mut instance); + c693_l1729_action_invoke(&mut instance); + c694_l1730_action_invoke(&mut instance); + c695_l1731_action_invoke(&mut instance); + c696_l1733_action_invoke(&mut instance); + c697_l1734_action_invoke(&mut instance); + c698_l1735_action_invoke(&mut instance); + c699_l1736_action_invoke(&mut instance); + c700_l1737_action_invoke(&mut instance); +} +fn create_module_71() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32 f32) (result f32))) + (type (;1;) (func (param f64 f64 f64) (result f64))) + (func (;0;) (type 0) (param f32 f32 f32) (result f32) + get_local 0 + get_local 2 + f32.div + get_local 1 + get_local 2 + f32.div + f32.add) + (func (;1;) (type 1) (param f64 f64 f64) (result f64) + get_local 0 + get_local 2 + f64.div + get_local 1 + get_local 2 + f64.div + f64.add) + (export \"f32.no_fold_add_divs\" (func 0)) + (export \"f64.no_fold_add_divs\" (func 1))) + "; + 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_71(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 1749 +fn c702_l1749_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c702_l1749_action_invoke"); + let result = instance.call("f32.no_fold_add_divs", &[Value::F32((377.3689f32).to_bits()), Value::F32((-0.040118184f32).to_bits()), Value::F32((-136292990000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0000000000000000000000000000000000027685121f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1750 +fn c703_l1750_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c703_l1750_action_invoke"); + let result = instance.call("f32.no_fold_add_divs", &[Value::F32((-0.00000000000000000018234023f32).to_bits()), Value::F32((-0.0000000000000033970288f32).to_bits()), Value::F32((-170996700000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000019867115f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1751 +fn c704_l1751_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c704_l1751_action_invoke"); + let result = instance.call("f32.no_fold_add_divs", &[Value::F32((-0.000000000000019672638f32).to_bits()), Value::F32((0.00000000000000000006414099f32).to_bits()), Value::F32((-541989070000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000036296997f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1752 +fn c705_l1752_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c705_l1752_action_invoke"); + let result = instance.call("f32.no_fold_add_divs", &[Value::F32((-0.0000000000000000000000000000004038506f32).to_bits()), Value::F32((0.000000000000000000000000000003848228f32).to_bits()), Value::F32((-345237200000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1753 +fn c706_l1753_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c706_l1753_action_invoke"); + let result = instance.call("f32.no_fold_add_divs", &[Value::F32((0.0010934415f32).to_bits()), Value::F32((0.20703124f32).to_bits()), Value::F32((0.00000000000000000000000000000000000013509784f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1540547700000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1755 +fn c707_l1755_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c707_l1755_action_invoke"); + let result = instance.call("f64.no_fold_add_divs", &[Value::F64((-4917019432143760000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((68132156322019020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((26125410100237784000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024196801752520584f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1756 +fn c708_l1756_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c708_l1756_action_invoke"); + let result = instance.call("f64.no_fold_add_divs", &[Value::F64((-10206467953224550.0f64).to_bits()), Value::F64((63.422616671746226f64).to_bits()), Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016024747869814892f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6369190976445851000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1757 +fn c709_l1757_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c709_l1757_action_invoke"); + let result = instance.call("f64.no_fold_add_divs", &[Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015270569633109837f64).to_bits()), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000025755503329232514f64).to_bits()), Value::F64((58826939164214920000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1758 +fn c710_l1758_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c710_l1758_action_invoke"); + let result = instance.call("f64.no_fold_add_divs", &[Value::F64((26667964874394640000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-2131569252493657800000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000012377004518680012f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-172217969324625340000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1759 +fn c711_l1759_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c711_l1759_action_invoke"); + let result = instance.call("f64.no_fold_add_divs", &[Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012952888377288216f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005808769259900048f64).to_bits()), Value::F64((0.0000000000000000000016745741699443756f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007735034106987796f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1763 + +#[test] +fn test_module_71() { + let mut instance = create_module_71(); + // We group the calls together + start_module_71(&mut instance); + c702_l1749_action_invoke(&mut instance); + c703_l1750_action_invoke(&mut instance); + c704_l1751_action_invoke(&mut instance); + c705_l1752_action_invoke(&mut instance); + c706_l1753_action_invoke(&mut instance); + c707_l1755_action_invoke(&mut instance); + c708_l1756_action_invoke(&mut instance); + c709_l1757_action_invoke(&mut instance); + c710_l1758_action_invoke(&mut instance); + c711_l1759_action_invoke(&mut instance); +} +fn create_module_72() -> Box { + let module_str = "(module + (type (;0;) (func (param f32) (result f32))) + (type (;1;) (func (param f64) (result f64))) + (func (;0;) (type 0) (param f32) (result f32) + get_local 0 + get_local 0 + f32.mul + f32.sqrt) + (func (;1;) (type 1) (param f64) (result f64) + get_local 0 + get_local 0 + f64.mul + f64.sqrt) + (export \"f32.no_fold_sqrt_square\" (func 0)) + (export \"f64.no_fold_sqrt_square\" (func 1))) + "; + 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_72(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 1771 +fn c713_l1771_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c713_l1771_action_invoke"); + let result = instance.call("f32.no_fold_sqrt_square", &[Value::F32((-0.00000000000000000001846f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000001846001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1772 +fn c714_l1772_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c714_l1772_action_invoke"); + let result = instance.call("f32.no_fold_sqrt_square", &[Value::F32((-0.00000000000000000000017907473f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000000017952678f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1773 +fn c715_l1773_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c715_l1773_action_invoke"); + let result = instance.call("f32.no_fold_sqrt_square", &[Value::F32((-0.00000000000000000000079120785f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000791442f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1774 +fn c716_l1774_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c716_l1774_action_invoke"); + let result = instance.call("f32.no_fold_sqrt_square", &[Value::F32((0.000000000000000000000000018012938f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1775 +fn c717_l1775_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c717_l1775_action_invoke"); + let result = instance.call("f32.no_fold_sqrt_square", &[Value::F32((610501970000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1777 +fn c718_l1777_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c718_l1777_action_invoke"); + let result = instance.call("f64.no_fold_sqrt_square", &[Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006209297167747496f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006209299542179727f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1778 +fn c719_l1778_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c719_l1778_action_invoke"); + let result = instance.call("f64.no_fold_sqrt_square", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024211175303738945f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024211175303738937f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1779 +fn c720_l1779_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c720_l1779_action_invoke"); + let result = instance.call("f64.no_fold_sqrt_square", &[Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016460687611875645f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016460687611532367f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1780 +fn c721_l1780_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c721_l1780_action_invoke"); + let result = instance.call("f64.no_fold_sqrt_square", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003797811613378828f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1781 +fn c722_l1781_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c722_l1781_action_invoke"); + let result = instance.call("f64.no_fold_sqrt_square", &[Value::F64((815808428460559200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1785 + +#[test] +fn test_module_72() { + let mut instance = create_module_72(); + // We group the calls together + start_module_72(&mut instance); + c713_l1771_action_invoke(&mut instance); + c714_l1772_action_invoke(&mut instance); + c715_l1773_action_invoke(&mut instance); + c716_l1774_action_invoke(&mut instance); + c717_l1775_action_invoke(&mut instance); + c718_l1777_action_invoke(&mut instance); + c719_l1778_action_invoke(&mut instance); + c720_l1779_action_invoke(&mut instance); + c721_l1780_action_invoke(&mut instance); + c722_l1781_action_invoke(&mut instance); +} +fn create_module_73() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32) (result f32))) + (type (;1;) (func (param f64 f64) (result f64))) + (func (;0;) (type 0) (param f32 f32) (result f32) + get_local 0 + f32.sqrt + get_local 1 + f32.sqrt + f32.mul) + (func (;1;) (type 1) (param f64 f64) (result f64) + get_local 0 + f64.sqrt + get_local 1 + f64.sqrt + f64.mul) + (export \"f32.no_fold_mul_sqrts\" (func 0)) + (export \"f64.no_fold_mul_sqrts\" (func 1))) + "; + 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_73(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 1793 +fn c724_l1793_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c724_l1793_assert_return_canonical_nan"); + let result = instance.call("f32.no_fold_mul_sqrts", &[Value::F32((0.000000000000000000000000000000000000043885047f32).to_bits()), Value::F32((-0.00000000000000000000000011867334f32).to_bits())]).unwrap().expect("Missing result in c724_l1793_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1794 +fn c725_l1794_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c725_l1794_action_invoke"); + let result = instance.call("f32.no_fold_mul_sqrts", &[Value::F32((0.00000000000000000000000000025365908f32).to_bits()), Value::F32((0.00000000041320675f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000032374932f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1795 +fn c726_l1795_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c726_l1795_action_invoke"); + let result = instance.call("f32.no_fold_mul_sqrts", &[Value::F32((0.0000000000000000000000000042144832f32).to_bits()), Value::F32((97.249115f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.00000000000064019905f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1796 +fn c727_l1796_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c727_l1796_action_invoke"); + let result = instance.call("f32.no_fold_mul_sqrts", &[Value::F32((3724076300000000000000000000000.0f32).to_bits()), Value::F32((0.002944908f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((104723750000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1797 +fn c728_l1797_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c728_l1797_action_invoke"); + let result = instance.call("f32.no_fold_mul_sqrts", &[Value::F32((0.00000000000000001866056f32).to_bits()), Value::F32((0.002111261f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.00000000019848755f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1799 +fn c729_l1799_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c729_l1799_assert_return_canonical_nan"); + let result = instance.call("f64.no_fold_mul_sqrts", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012742064369772862f64).to_bits()), Value::F64((-0.006829962938197246f64).to_bits())]).unwrap().expect("Missing result in c729_l1799_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1800 +fn c730_l1800_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c730_l1800_action_invoke"); + let result = instance.call("f64.no_fold_mul_sqrts", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000037082569269527534f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000047183002857015043f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000041829020688865954f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1801 +fn c731_l1801_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c731_l1801_action_invoke"); + let result = instance.call("f64.no_fold_mul_sqrts", &[Value::F64((0.000000000000000000000000002329359505918655f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020743399642806364f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000021981545701574452f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1802 +fn c732_l1802_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c732_l1802_action_invoke"); + let result = instance.call("f64.no_fold_mul_sqrts", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010541899336289437f64).to_bits()), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000598123819872803f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002511047809129887f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1803 +fn c733_l1803_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c733_l1803_action_invoke"); + let result = instance.call("f64.no_fold_mul_sqrts", &[Value::F64((25589482.717358638f64).to_bits()), Value::F64((39138912071199020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1000771959050695500000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1807 + +#[test] +fn test_module_73() { + let mut instance = create_module_73(); + // We group the calls together + start_module_73(&mut instance); + c724_l1793_assert_return_canonical_nan(&mut instance); + c725_l1794_action_invoke(&mut instance); + c726_l1795_action_invoke(&mut instance); + c727_l1796_action_invoke(&mut instance); + c728_l1797_action_invoke(&mut instance); + c729_l1799_assert_return_canonical_nan(&mut instance); + c730_l1800_action_invoke(&mut instance); + c731_l1801_action_invoke(&mut instance); + c732_l1802_action_invoke(&mut instance); + c733_l1803_action_invoke(&mut instance); +} +fn create_module_74() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32) (result f32))) + (type (;1;) (func (param f64 f64) (result f64))) + (func (;0;) (type 0) (param f32 f32) (result f32) + get_local 0 + f32.sqrt + get_local 1 + f32.sqrt + f32.div) + (func (;1;) (type 1) (param f64 f64) (result f64) + get_local 0 + f64.sqrt + get_local 1 + f64.sqrt + f64.div) + (export \"f32.no_fold_div_sqrts\" (func 0)) + (export \"f64.no_fold_div_sqrts\" (func 1))) + "; + 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_74(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 1815 +fn c735_l1815_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c735_l1815_assert_return_canonical_nan"); + let result = instance.call("f32.no_fold_div_sqrts", &[Value::F32((-58545012.0f32).to_bits()), Value::F32((-0.000000000000000006443773f32).to_bits())]).unwrap().expect("Missing result in c735_l1815_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1816 +fn c736_l1816_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c736_l1816_action_invoke"); + let result = instance.call("f32.no_fold_div_sqrts", &[Value::F32((7407384000.0f32).to_bits()), Value::F32((209778930.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((5.9422584f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1817 +fn c737_l1817_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c737_l1817_action_invoke"); + let result = instance.call("f32.no_fold_div_sqrts", &[Value::F32((0.0000000000000000000000000000000000013764126f32).to_bits()), Value::F32((54692.9f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000050165927f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1818 +fn c738_l1818_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c738_l1818_action_invoke"); + let result = instance.call("f32.no_fold_div_sqrts", &[Value::F32((979288960000000000.0f32).to_bits()), Value::F32((0.0000000012643552f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((27830490000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1819 +fn c739_l1819_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c739_l1819_action_invoke"); + let result = instance.call("f32.no_fold_div_sqrts", &[Value::F32((0.00000000000000000000000000000000029141283f32).to_bits()), Value::F32((0.00000000000000000000000000000017928174f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.04031682f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1821 +fn c740_l1821_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c740_l1821_assert_return_canonical_nan"); + let result = instance.call("f64.no_fold_div_sqrts", &[Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012206137319883022f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000008209583449676083f64).to_bits())]).unwrap().expect("Missing result in c740_l1821_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 1822 +fn c741_l1822_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c741_l1822_action_invoke"); + let result = instance.call("f64.no_fold_div_sqrts", &[Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000033818852462305824f64).to_bits()), Value::F64((7655783976315048000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000021017671425665687f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1823 +fn c742_l1823_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c742_l1823_action_invoke"); + let result = instance.call("f64.no_fold_div_sqrts", &[Value::F64((45963335670647510000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.0000000000000000000000000000000023932467846883046f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((138583660172663150000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1824 +fn c743_l1824_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c743_l1824_action_invoke"); + let result = instance.call("f64.no_fold_div_sqrts", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000025327340978668086f64).to_bits()), Value::F64((4475305129961258000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000023789399141325018f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1825 +fn c744_l1825_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c744_l1825_action_invoke"); + let result = instance.call("f64.no_fold_div_sqrts", &[Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005103070160197939f64).to_bits()), Value::F64((460157669098082500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010530826009924495f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1829 + +#[test] +fn test_module_74() { + let mut instance = create_module_74(); + // We group the calls together + start_module_74(&mut instance); + c735_l1815_assert_return_canonical_nan(&mut instance); + c736_l1816_action_invoke(&mut instance); + c737_l1817_action_invoke(&mut instance); + c738_l1818_action_invoke(&mut instance); + c739_l1819_action_invoke(&mut instance); + c740_l1821_assert_return_canonical_nan(&mut instance); + c741_l1822_action_invoke(&mut instance); + c742_l1823_action_invoke(&mut instance); + c743_l1824_action_invoke(&mut instance); + c744_l1825_action_invoke(&mut instance); +} +fn create_module_75() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32) (result f32))) + (type (;1;) (func (param f64 f64) (result f64))) + (func (;0;) (type 0) (param f32 f32) (result f32) + get_local 0 + get_local 1 + f32.sqrt + f32.mul + get_local 1 + f32.div) + (func (;1;) (type 1) (param f64 f64) (result f64) + get_local 0 + get_local 1 + f64.sqrt + f64.mul + get_local 1 + f64.div) + (export \"f32.no_fold_mul_sqrt_div\" (func 0)) + (export \"f64.no_fold_mul_sqrt_div\" (func 1))) + "; + 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_75(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 1837 +fn c746_l1837_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c746_l1837_action_invoke"); + let result = instance.call("f32.no_fold_mul_sqrt_div", &[Value::F32((-4728556800000000000000000.0f32).to_bits()), Value::F32((8677282000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1838 +fn c747_l1838_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c747_l1838_action_invoke"); + let result = instance.call("f32.no_fold_mul_sqrt_div", &[Value::F32((-0.0000000000000000000000000000000000011776882f32).to_bits()), Value::F32((0.000000000000000000000000000009805153f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1839 +fn c748_l1839_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c748_l1839_action_invoke"); + let result = instance.call("f32.no_fold_mul_sqrt_div", &[Value::F32((816717060.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000003323171f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((14167568000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1840 +fn c749_l1840_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c749_l1840_action_invoke"); + let result = instance.call("f32.no_fold_mul_sqrt_div", &[Value::F32((-11932267000000.0f32).to_bits()), Value::F32((8637067000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.00012839255f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1841 +fn c750_l1841_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c750_l1841_action_invoke"); + let result = instance.call("f32.no_fold_mul_sqrt_div", &[Value::F32((-401.0235f32).to_bits()), Value::F32((134.33022f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-34.600548f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1843 +fn c751_l1843_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c751_l1843_action_invoke"); + let result = instance.call("f64.no_fold_mul_sqrt_div", &[Value::F64((1468134622910490500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((2466074582285183000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 1844 +fn c752_l1844_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c752_l1844_action_invoke"); + let result = instance.call("f64.no_fold_mul_sqrt_div", &[Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017254022016758028f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000055835540747130025f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1845 +fn c753_l1845_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c753_l1845_action_invoke"); + let result = instance.call("f64.no_fold_mul_sqrt_div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016812810256029166f64).to_bits()), Value::F64((7362783602442129000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006196112486187196f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1846 +fn c754_l1846_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c754_l1846_action_invoke"); + let result = instance.call("f64.no_fold_mul_sqrt_div", &[Value::F64((-10605483729939836000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000622591783694072f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-42503900822233765000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1847 +fn c755_l1847_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c755_l1847_action_invoke"); + let result = instance.call("f64.no_fold_mul_sqrt_div", &[Value::F64((26336349695373093000000000000000.0f64).to_bits()), Value::F64((30791413285853300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004746142447510695f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1852 + +#[test] +fn test_module_75() { + let mut instance = create_module_75(); + // We group the calls together + start_module_75(&mut instance); + c746_l1837_action_invoke(&mut instance); + c747_l1838_action_invoke(&mut instance); + c748_l1839_action_invoke(&mut instance); + c749_l1840_action_invoke(&mut instance); + c750_l1841_action_invoke(&mut instance); + c751_l1843_action_invoke(&mut instance); + c752_l1844_action_invoke(&mut instance); + c753_l1845_action_invoke(&mut instance); + c754_l1846_action_invoke(&mut instance); + c755_l1847_action_invoke(&mut instance); +} +fn create_module_76() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32 f32) (result f32))) + (type (;1;) (func (param f64 f64 f64) (result f64))) + (func (;0;) (type 0) (param f32 f32 f32) (result f32) + get_local 0 + get_local 1 + f32.mul + get_local 2 + f32.mul) + (func (;1;) (type 1) (param f64 f64 f64) (result f64) + get_local 0 + get_local 1 + f64.mul + get_local 2 + f64.mul) + (export \"f32.no_flush_intermediate_subnormal\" (func 0)) + (export \"f64.no_flush_intermediate_subnormal\" (func 1))) + "; + 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_76(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 1860 +fn c757_l1860_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c757_l1860_action_invoke"); + let result = instance.call("f32.no_flush_intermediate_subnormal", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.00000011920929f32).to_bits()), Value::F32((8388608.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1861 +fn c758_l1861_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c758_l1861_action_invoke"); + let result = instance.call("f64.no_flush_intermediate_subnormal", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.0000000000000002220446049250313f64).to_bits()), Value::F64((4503599627370496.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1866 + +#[test] +fn test_module_76() { + let mut instance = create_module_76(); + // We group the calls together + start_module_76(&mut instance); + c757_l1860_action_invoke(&mut instance); + c758_l1861_action_invoke(&mut instance); +} +fn create_module_77() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32) (result i32))) + (type (;1;) (func (param f64 f64) (result i32))) + (type (;2;) (func (param f64 f32) (result f32))) + (func (;0;) (type 0) (param f32 f32) (result i32) + get_local 0 + get_local 1 + f32.mul + get_local 0 + f32.eq) + (func (;1;) (type 0) (param f32 f32) (result i32) + get_local 0 + get_local 1 + f32.mul + get_local 0 + f32.le) + (func (;2;) (type 0) (param f32 f32) (result i32) + get_local 0 + get_local 1 + f32.mul + get_local 0 + f32.lt) + (func (;3;) (type 1) (param f64 f64) (result i32) + get_local 0 + get_local 1 + f64.mul + get_local 0 + f64.eq) + (func (;4;) (type 1) (param f64 f64) (result i32) + get_local 0 + get_local 1 + f64.mul + get_local 0 + f64.le) + (func (;5;) (type 1) (param f64 f64) (result i32) + get_local 0 + get_local 1 + f64.mul + get_local 0 + f64.lt) + (func (;6;) (type 2) (param f64 f32) (result f32) + get_local 0 + f32.demote/f64 + get_local 1 + f32.mul) + (export \"f32.recoding_eq\" (func 0)) + (export \"f32.recoding_le\" (func 1)) + (export \"f32.recoding_lt\" (func 2)) + (export \"f64.recoding_eq\" (func 3)) + (export \"f64.recoding_le\" (func 4)) + (export \"f64.recoding_lt\" (func 5)) + (export \"recoding_demote\" (func 6))) + "; + 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_77(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 1889 +fn c760_l1889_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c760_l1889_action_invoke"); + let result = instance.call("f32.recoding_eq", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((3.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1890 +fn c761_l1890_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c761_l1890_action_invoke"); + let result = instance.call("f32.recoding_le", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((3.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1891 +fn c762_l1891_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c762_l1891_action_invoke"); + let result = instance.call("f32.recoding_lt", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((3.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1893 +fn c763_l1893_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c763_l1893_action_invoke"); + let result = instance.call("f32.recoding_eq", &[Value::F32((0.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1894 +fn c764_l1894_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c764_l1894_action_invoke"); + let result = instance.call("f32.recoding_le", &[Value::F32((0.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1895 +fn c765_l1895_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c765_l1895_action_invoke"); + let result = instance.call("f32.recoding_lt", &[Value::F32((0.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1897 +fn c766_l1897_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c766_l1897_action_invoke"); + let result = instance.call("f64.recoding_eq", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((3.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1898 +fn c767_l1898_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c767_l1898_action_invoke"); + let result = instance.call("f64.recoding_le", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((3.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1899 +fn c768_l1899_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c768_l1899_action_invoke"); + let result = instance.call("f64.recoding_lt", &[Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64((3.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1901 +fn c769_l1901_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c769_l1901_action_invoke"); + let result = instance.call("f64.recoding_eq", &[Value::F64((0.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1902 +fn c770_l1902_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c770_l1902_action_invoke"); + let result = instance.call("f64.recoding_le", &[Value::F64((0.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1903 +fn c771_l1903_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c771_l1903_action_invoke"); + let result = instance.call("f64.recoding_lt", &[Value::F64((0.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 1905 +fn c772_l1905_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c772_l1905_action_invoke"); + let result = instance.call("recoding_demote", &[Value::F64((0.00000000000000000000000000000000000000023860049081905093f64).to_bits()), Value::F32((1221.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000000000000000000002913312f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1910 + +#[test] +fn test_module_77() { + let mut instance = create_module_77(); + // We group the calls together + start_module_77(&mut instance); + c760_l1889_action_invoke(&mut instance); + c761_l1890_action_invoke(&mut instance); + c762_l1891_action_invoke(&mut instance); + c763_l1893_action_invoke(&mut instance); + c764_l1894_action_invoke(&mut instance); + c765_l1895_action_invoke(&mut instance); + c766_l1897_action_invoke(&mut instance); + c767_l1898_action_invoke(&mut instance); + c768_l1899_action_invoke(&mut instance); + c769_l1901_action_invoke(&mut instance); + c770_l1902_action_invoke(&mut instance); + c771_l1903_action_invoke(&mut instance); + c772_l1905_action_invoke(&mut instance); +} +fn create_module_78() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32 f32) (result i32))) + (type (;1;) (func (param f64 f64 f64) (result i32))) + (func (;0;) (type 0) (param f32 f32 f32) (result i32) + get_local 0 + get_local 1 + f32.div + get_local 2 + f32.eq) + (func (;1;) (type 1) (param f64 f64 f64) (result i32) + get_local 0 + get_local 1 + f64.div + get_local 2 + f64.eq) + (export \"f32.no_extended_precision_div\" (func 0)) + (export \"f64.no_extended_precision_div\" (func 1))) + "; + 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_78(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 1918 +fn c774_l1918_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c774_l1918_action_invoke"); + let result = instance.call("f32.no_extended_precision_div", &[Value::F32((3.0f32).to_bits()), Value::F32((7.0f32).to_bits()), Value::F32((0.42857143f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1919 +fn c775_l1919_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c775_l1919_action_invoke"); + let result = instance.call("f64.no_extended_precision_div", &[Value::F64((3.0f64).to_bits()), Value::F64((7.0f64).to_bits()), Value::F64((0.42857142857142855f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 1926 + +#[test] +fn test_module_78() { + let mut instance = create_module_78(); + // We group the calls together + start_module_78(&mut instance); + c774_l1918_action_invoke(&mut instance); + c775_l1919_action_invoke(&mut instance); +} +fn create_module_79() -> Box { + let module_str = "(module + (type (;0;) (func (param f32) (result f32))) + (type (;1;) (func (param f64) (result f64))) + (func (;0;) (type 0) (param f32) (result f32) + f32.const -0x1p+3 (;=-8;) + get_local 0 + f32.mul + f32.const 0x1p+3 (;=8;) + get_local 0 + f32.mul + f32.add) + (func (;1;) (type 1) (param f64) (result f64) + f64.const -0x1p+3 (;=-8;) + get_local 0 + f64.mul + f64.const 0x1p+3 (;=8;) + get_local 0 + f64.mul + f64.add) + (export \"f32.no_distribute_exact\" (func 0)) + (export \"f64.no_distribute_exact\" (func 1))) + "; + 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_79(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 1934 +fn c777_l1934_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c777_l1934_action_invoke"); + let result = instance.call("f32.no_distribute_exact", &[Value::F32((-0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1935 +fn c778_l1935_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c778_l1935_action_invoke"); + let result = instance.call("f64.no_distribute_exact", &[Value::F64((-0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1940 + +#[test] +fn test_module_79() { + let mut instance = create_module_79(); + // We group the calls together + start_module_79(&mut instance); + c777_l1934_action_invoke(&mut instance); + c778_l1935_action_invoke(&mut instance); +} +fn create_module_80() -> Box { + let module_str = "(module + (type (;0;) (func (param f32) (result f32))) + (type (;1;) (func (param f32 f32 f32 f32) (result f32))) + (type (;2;) (func (param f32 f32 f32) (result f32))) + (type (;3;) (func (param f64) (result f64))) + (type (;4;) (func (param f64 f64 f64 f64) (result f64))) + (type (;5;) (func (param f64 f64 f64) (result f64))) + (func (;0;) (type 0) (param f32) (result f32) + get_local 0 + f32.sqrt) + (func (;1;) (type 1) (param f32 f32 f32 f32) (result f32) + get_local 0 + get_local 1 + f32.div + get_local 2 + get_local 3 + get_local 2 + f32.sub + f32.div + f32.add) + (func (;2;) (type 2) (param f32 f32 f32) (result f32) + get_local 0 + get_local 1 + f32.mul + get_local 2 + f32.div) + (func (;3;) (type 2) (param f32 f32 f32) (result f32) + get_local 0 + get_local 1 + f32.div + get_local 2 + get_local 0 + f32.div + f32.add) + (func (;4;) (type 1) (param f32 f32 f32 f32) (result f32) + get_local 0 + get_local 1 + get_local 2 + f32.mul + f32.add + get_local 3 + get_local 1 + get_local 2 + f32.mul + f32.sub + f32.div) + (func (;5;) (type 3) (param f64) (result f64) + get_local 0 + f64.sqrt) + (func (;6;) (type 4) (param f64 f64 f64 f64) (result f64) + get_local 0 + get_local 1 + f64.div + get_local 2 + get_local 3 + get_local 2 + f64.sub + f64.div + f64.add) + (func (;7;) (type 5) (param f64 f64 f64) (result f64) + get_local 0 + get_local 1 + f64.mul + get_local 2 + f64.div) + (func (;8;) (type 5) (param f64 f64 f64) (result f64) + get_local 0 + get_local 1 + f64.div + get_local 2 + get_local 0 + f64.div + f64.add) + (func (;9;) (type 4) (param f64 f64 f64 f64) (result f64) + get_local 0 + get_local 1 + get_local 2 + f64.mul + f64.add + get_local 3 + get_local 1 + get_local 2 + f64.mul + f64.sub + f64.div) + (export \"f32.sqrt\" (func 0)) + (export \"f32.xkcd_sqrt_2\" (func 1)) + (export \"f32.xkcd_sqrt_3\" (func 2)) + (export \"f32.xkcd_sqrt_5\" (func 3)) + (export \"f32.xkcd_better_sqrt_5\" (func 4)) + (export \"f64.sqrt\" (func 5)) + (export \"f64.xkcd_sqrt_2\" (func 6)) + (export \"f64.xkcd_sqrt_3\" (func 7)) + (export \"f64.xkcd_sqrt_5\" (func 8)) + (export \"f64.xkcd_better_sqrt_5\" (func 9))) + "; + 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_80(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 1972 +fn c780_l1972_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c780_l1972_action_invoke"); + let result = instance.call("f32.sqrt", &[Value::F32((2.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.4142135f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1973 +fn c781_l1973_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c781_l1973_action_invoke"); + let result = instance.call("f32.xkcd_sqrt_2", &[Value::F32((3.0f32).to_bits()), Value::F32((5.0f32).to_bits()), Value::F32((3.1415927f32).to_bits()), Value::F32((7.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.4142201f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1974 +fn c782_l1974_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c782_l1974_action_invoke"); + let result = instance.call("f32.sqrt", &[Value::F32((3.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.7320508f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1975 +fn c783_l1975_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c783_l1975_action_invoke"); + let result = instance.call("f32.xkcd_sqrt_3", &[Value::F32((2.0f32).to_bits()), Value::F32((2.7182817f32).to_bits()), Value::F32((3.1415927f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.7305119f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1976 +fn c784_l1976_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c784_l1976_action_invoke"); + let result = instance.call("f32.sqrt", &[Value::F32((5.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((2.236068f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1977 +fn c785_l1977_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c785_l1977_action_invoke"); + let result = instance.call("f32.xkcd_sqrt_5", &[Value::F32((2.0f32).to_bits()), Value::F32((2.7182817f32).to_bits()), Value::F32((3.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((2.2357588f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1978 +fn c786_l1978_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c786_l1978_action_invoke"); + let result = instance.call("f32.xkcd_better_sqrt_5", &[Value::F32((13.0f32).to_bits()), Value::F32((4.0f32).to_bits()), Value::F32((3.1415927f32).to_bits()), Value::F32((24.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((2.236068f32).to_bits())))); + result.map(|_| ()) +} + +// Line 1980 +fn c787_l1980_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c787_l1980_action_invoke"); + let result = instance.call("f64.sqrt", &[Value::F64((2.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.4142135623730951f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1981 +fn c788_l1981_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c788_l1981_action_invoke"); + let result = instance.call("f64.xkcd_sqrt_2", &[Value::F64((3.0f64).to_bits()), Value::F64((5.0f64).to_bits()), Value::F64((3.141592653589793f64).to_bits()), Value::F64((7.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.4142200580539208f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1982 +fn c789_l1982_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c789_l1982_action_invoke"); + let result = instance.call("f64.sqrt", &[Value::F64((3.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.7320508075688772f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1983 +fn c790_l1983_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c790_l1983_action_invoke"); + let result = instance.call("f64.xkcd_sqrt_3", &[Value::F64((2.0f64).to_bits()), Value::F64((2.718281828459045f64).to_bits()), Value::F64((3.141592653589793f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.7305119588645301f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1984 +fn c791_l1984_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c791_l1984_action_invoke"); + let result = instance.call("f64.sqrt", &[Value::F64((5.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((2.23606797749979f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1985 +fn c792_l1985_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c792_l1985_action_invoke"); + let result = instance.call("f64.xkcd_sqrt_5", &[Value::F64((2.0f64).to_bits()), Value::F64((2.718281828459045f64).to_bits()), Value::F64((3.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((2.2357588823428847f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1986 +fn c793_l1986_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c793_l1986_action_invoke"); + let result = instance.call("f64.xkcd_better_sqrt_5", &[Value::F64((13.0f64).to_bits()), Value::F64((4.0f64).to_bits()), Value::F64((3.141592653589793f64).to_bits()), Value::F64((24.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((2.2360678094452893f64).to_bits())))); + result.map(|_| ()) +} + +// Line 1991 + +#[test] +fn test_module_80() { + let mut instance = create_module_80(); + // We group the calls together + start_module_80(&mut instance); + c780_l1972_action_invoke(&mut instance); + c781_l1973_action_invoke(&mut instance); + c782_l1974_action_invoke(&mut instance); + c783_l1975_action_invoke(&mut instance); + c784_l1976_action_invoke(&mut instance); + c785_l1977_action_invoke(&mut instance); + c786_l1978_action_invoke(&mut instance); + c787_l1980_action_invoke(&mut instance); + c788_l1981_action_invoke(&mut instance); + c789_l1982_action_invoke(&mut instance); + c790_l1983_action_invoke(&mut instance); + c791_l1984_action_invoke(&mut instance); + c792_l1985_action_invoke(&mut instance); + c793_l1986_action_invoke(&mut instance); +} +fn create_module_81() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32) (result f32))) + (type (;1;) (func (param f64 f64) (result f64))) + (func (;0;) (type 0) (param f32 f32) (result f32) + loop ;; label = @1 + get_local 0 + get_local 0 + f32.add + tee_local 0 + f32.const 0x1p+0 (;=1;) + f32.add + get_local 0 + f32.sub + f32.const -0x1p+0 (;=-1;) + f32.add + f32.const 0x0p+0 (;=0;) + f32.eq + br_if 0 (;@1;) + end + loop ;; label = @1 + get_local 0 + get_local 1 + f32.const 0x1p+0 (;=1;) + f32.add + tee_local 1 + f32.add + get_local 0 + f32.sub + get_local 1 + f32.sub + f32.const 0x0p+0 (;=0;) + f32.ne + br_if 0 (;@1;) + end + get_local 1) + (func (;1;) (type 1) (param f64 f64) (result f64) + loop ;; label = @1 + get_local 0 + get_local 0 + f64.add + tee_local 0 + f64.const 0x1p+0 (;=1;) + f64.add + get_local 0 + f64.sub + f64.const -0x1p+0 (;=-1;) + f64.add + f64.const 0x0p+0 (;=0;) + f64.eq + br_if 0 (;@1;) + end + loop ;; label = @1 + get_local 0 + get_local 1 + f64.const 0x1p+0 (;=1;) + f64.add + tee_local 1 + f64.add + get_local 0 + f64.sub + get_local 1 + f64.sub + f64.const 0x0p+0 (;=0;) + f64.ne + br_if 0 (;@1;) + end + get_local 1) + (export \"f32.compute_radix\" (func 0)) + (export \"f64.compute_radix\" (func 1))) + "; + 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_81(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 2069 +fn c795_l2069_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c795_l2069_action_invoke"); + let result = instance.call("f32.compute_radix", &[Value::F32((1.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((2.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2070 +fn c796_l2070_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c796_l2070_action_invoke"); + let result = instance.call("f64.compute_radix", &[Value::F64((1.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((2.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2075 + +#[test] +fn test_module_81() { + let mut instance = create_module_81(); + // We group the calls together + start_module_81(&mut instance); + c795_l2069_action_invoke(&mut instance); + c796_l2070_action_invoke(&mut instance); +} +fn create_module_82() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32) (result f32))) + (type (;1;) (func (param f64 f64) (result f64))) + (func (;0;) (type 0) (param f32 f32) (result f32) + get_local 0 + f32.const 0x1p+0 (;=1;) + f32.sub + get_local 1 + f32.mul + get_local 1 + f32.add) + (func (;1;) (type 1) (param f64 f64) (result f64) + get_local 0 + f64.const 0x1p+0 (;=1;) + f64.sub + get_local 1 + f64.mul + get_local 1 + f64.add) + (export \"f32.no_fold_sub1_mul_add\" (func 0)) + (export \"f64.no_fold_sub1_mul_add\" (func 1))) + "; + 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_82(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 2083 +fn c798_l2083_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c798_l2083_action_invoke"); + let result = instance.call("f32.no_fold_sub1_mul_add", &[Value::F32((0.00000000023283064f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2084 +fn c799_l2084_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c799_l2084_action_invoke"); + let result = instance.call("f64.no_fold_sub1_mul_add", &[Value::F64((0.00000000000000000005421010862427522f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2089 + +#[test] +fn test_module_82() { + let mut instance = create_module_82(); + // We group the calls together + start_module_82(&mut instance); + c798_l2083_action_invoke(&mut instance); + c799_l2084_action_invoke(&mut instance); +} +fn create_module_83() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32 f32) (result i32))) + (type (;1;) (func (param f64 f64 f64) (result i32))) + (func (;0;) (type 0) (param f32 f32 f32) (result i32) + get_local 0 + get_local 2 + f32.add + get_local 1 + get_local 2 + f32.add + f32.le) + (func (;1;) (type 0) (param f32 f32 f32) (result i32) + get_local 0 + get_local 2 + f32.add + get_local 1 + get_local 2 + f32.add + f32.ge) + (func (;2;) (type 1) (param f64 f64 f64) (result i32) + get_local 0 + get_local 2 + f64.add + get_local 1 + get_local 2 + f64.add + f64.le) + (func (;3;) (type 1) (param f64 f64 f64) (result i32) + get_local 0 + get_local 2 + f64.add + get_local 1 + get_local 2 + f64.add + f64.ge) + (export \"f32.no_fold_add_le_monotonicity\" (func 0)) + (export \"f32.no_fold_add_ge_monotonicity\" (func 1)) + (export \"f64.no_fold_add_le_monotonicity\" (func 2)) + (export \"f64.no_fold_add_ge_monotonicity\" (func 3))) + "; + 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_83(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 2103 +fn c801_l2103_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c801_l2103_action_invoke"); + let result = instance.call("f32.no_fold_add_le_monotonicity", &[Value::F32((0.0f32).to_bits()), Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2104 +fn c802_l2104_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c802_l2104_action_invoke"); + let result = instance.call("f32.no_fold_add_le_monotonicity", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2105 +fn c803_l2105_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c803_l2105_action_invoke"); + let result = instance.call("f64.no_fold_add_le_monotonicity", &[Value::F64((0.0f64).to_bits()), Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2106 +fn c804_l2106_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c804_l2106_action_invoke"); + let result = instance.call("f64.no_fold_add_le_monotonicity", &[Value::F64(f64::INFINITY.to_bits()), Value::F64(f64::NEG_INFINITY.to_bits()), Value::F64(f64::INFINITY.to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2110 + +#[test] +fn test_module_83() { + let mut instance = create_module_83(); + // We group the calls together + start_module_83(&mut instance); + c801_l2103_action_invoke(&mut instance); + c802_l2104_action_invoke(&mut instance); + c803_l2105_action_invoke(&mut instance); + c804_l2106_action_invoke(&mut instance); +} +fn create_module_84() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32) (result i32))) + (type (;1;) (func (param f64 f64) (result i32))) + (func (;0;) (type 0) (param f32 f32) (result i32) + get_local 0 + get_local 1 + f32.lt + i32.eqz) + (func (;1;) (type 0) (param f32 f32) (result i32) + get_local 0 + get_local 1 + f32.le + i32.eqz) + (func (;2;) (type 0) (param f32 f32) (result i32) + get_local 0 + get_local 1 + f32.gt + i32.eqz) + (func (;3;) (type 0) (param f32 f32) (result i32) + get_local 0 + get_local 1 + f32.ge + i32.eqz) + (func (;4;) (type 1) (param f64 f64) (result i32) + get_local 0 + get_local 1 + f64.lt + i32.eqz) + (func (;5;) (type 1) (param f64 f64) (result i32) + get_local 0 + get_local 1 + f64.le + i32.eqz) + (func (;6;) (type 1) (param f64 f64) (result i32) + get_local 0 + get_local 1 + f64.gt + i32.eqz) + (func (;7;) (type 1) (param f64 f64) (result i32) + get_local 0 + get_local 1 + f64.ge + i32.eqz) + (export \"f32.not_lt\" (func 0)) + (export \"f32.not_le\" (func 1)) + (export \"f32.not_gt\" (func 2)) + (export \"f32.not_ge\" (func 3)) + (export \"f64.not_lt\" (func 4)) + (export \"f64.not_le\" (func 5)) + (export \"f64.not_gt\" (func 6)) + (export \"f64.not_ge\" (func 7))) + "; + 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_84(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 2136 +fn c806_l2136_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c806_l2136_action_invoke"); + let result = instance.call("f32.not_lt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2137 +fn c807_l2137_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c807_l2137_action_invoke"); + let result = instance.call("f32.not_le", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2138 +fn c808_l2138_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c808_l2138_action_invoke"); + let result = instance.call("f32.not_gt", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2139 +fn c809_l2139_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c809_l2139_action_invoke"); + let result = instance.call("f32.not_ge", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2140 +fn c810_l2140_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c810_l2140_action_invoke"); + let result = instance.call("f64.not_lt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2141 +fn c811_l2141_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c811_l2141_action_invoke"); + let result = instance.call("f64.not_le", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2142 +fn c812_l2142_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c812_l2142_action_invoke"); + let result = instance.call("f64.not_gt", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2143 +fn c813_l2143_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c813_l2143_action_invoke"); + let result = instance.call("f64.not_ge", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 2149 + +#[test] +fn test_module_84() { + let mut instance = create_module_84(); + // We group the calls together + start_module_84(&mut instance); + c806_l2136_action_invoke(&mut instance); + c807_l2137_action_invoke(&mut instance); + c808_l2138_action_invoke(&mut instance); + c809_l2139_action_invoke(&mut instance); + c810_l2140_action_invoke(&mut instance); + c811_l2141_action_invoke(&mut instance); + c812_l2142_action_invoke(&mut instance); + c813_l2143_action_invoke(&mut instance); +} +fn create_module_85() -> Box { + let module_str = "(module + (type (;0;) (func (result f32))) + (type (;1;) (func (result f64))) + (func (;0;) (type 0) (result f32) + f32.const 0x1p+0 (;=1;) + f32.const 0x1.8p+1 (;=3;) + f32.const 0x1p+2 (;=4;) + f32.const 0x1.8p+1 (;=3;) + f32.div + f32.const 0x1p+0 (;=1;) + f32.sub + f32.mul + f32.sub) + (func (;1;) (type 1) (result f64) + f64.const 0x1p+0 (;=1;) + f64.const 0x1.8p+1 (;=3;) + f64.const 0x1p+2 (;=4;) + f64.const 0x1.8p+1 (;=3;) + f64.div + f64.const 0x1p+0 (;=1;) + f64.sub + f64.mul + f64.sub) + (export \"f32.epsilon\" (func 0)) + (export \"f64.epsilon\" (func 1))) + "; + 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_85(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 2157 +fn c815_l2157_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c815_l2157_action_invoke"); + let result = instance.call("f32.epsilon", &[]); + assert_eq!(result, Ok(Some(Value::F32((-0.00000011920929f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2158 +fn c816_l2158_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c816_l2158_action_invoke"); + let result = instance.call("f64.epsilon", &[]); + assert_eq!(result, Ok(Some(Value::F64((0.0000000000000002220446049250313f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2164 + +#[test] +fn test_module_85() { + let mut instance = create_module_85(); + // We group the calls together + start_module_85(&mut instance); + c815_l2157_action_invoke(&mut instance); + c816_l2158_action_invoke(&mut instance); +} +fn create_module_86() -> Box { + let module_str = "(module + (type (;0;) (func (result f32))) + (type (;1;) (func (result f64))) + (func (;0;) (type 0) (result f32) + (local f32 f32) + f32.const 0x1p+0 (;=1;) + set_local 0 + loop ;; label = @1 + get_local 0 + tee_local 1 + f32.const 0x1p-1 (;=0.5;) + f32.mul + tee_local 0 + f32.const 0x1p+0 (;=1;) + f32.add + f32.const 0x1p+0 (;=1;) + f32.gt + br_if 0 (;@1;) + end + get_local 1) + (func (;1;) (type 1) (result f64) + (local f64 f64) + f64.const 0x1p+0 (;=1;) + set_local 0 + loop ;; label = @1 + get_local 0 + tee_local 1 + f64.const 0x1p-1 (;=0.5;) + f64.mul + tee_local 0 + f64.const 0x1p+0 (;=1;) + f64.add + f64.const 0x1p+0 (;=1;) + f64.gt + br_if 0 (;@1;) + end + get_local 1) + (export \"f32.epsilon\" (func 0)) + (export \"f64.epsilon\" (func 1))) + "; + 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_86(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 2212 +fn c818_l2212_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c818_l2212_action_invoke"); + let result = instance.call("f32.epsilon", &[]); + assert_eq!(result, Ok(Some(Value::F32((0.00000011920929f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2213 +fn c819_l2213_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c819_l2213_action_invoke"); + let result = instance.call("f64.epsilon", &[]); + assert_eq!(result, Ok(Some(Value::F64((0.0000000000000002220446049250313f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2218 + +#[test] +fn test_module_86() { + let mut instance = create_module_86(); + // We group the calls together + start_module_86(&mut instance); + c818_l2212_action_invoke(&mut instance); + c819_l2213_action_invoke(&mut instance); +} +fn create_module_87() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32) (result i32))) + (type (;1;) (func (param f64 f64) (result i32))) + (func (;0;) (type 0) (param f32 f32) (result i32) + get_local 0 + get_local 1 + f32.lt + get_local 0 + get_local 1 + f32.ge + i32.or) + (func (;1;) (type 0) (param f32 f32) (result i32) + get_local 0 + get_local 1 + f32.le + get_local 0 + get_local 1 + f32.gt + i32.or) + (func (;2;) (type 0) (param f32 f32) (result i32) + get_local 0 + get_local 1 + f32.gt + get_local 0 + get_local 1 + f32.le + i32.or) + (func (;3;) (type 0) (param f32 f32) (result i32) + get_local 0 + get_local 1 + f32.ge + get_local 0 + get_local 1 + f32.lt + i32.or) + (func (;4;) (type 1) (param f64 f64) (result i32) + get_local 0 + get_local 1 + f64.lt + get_local 0 + get_local 1 + f64.ge + i32.or) + (func (;5;) (type 1) (param f64 f64) (result i32) + get_local 0 + get_local 1 + f64.le + get_local 0 + get_local 1 + f64.gt + i32.or) + (func (;6;) (type 1) (param f64 f64) (result i32) + get_local 0 + get_local 1 + f64.gt + get_local 0 + get_local 1 + f64.le + i32.or) + (func (;7;) (type 1) (param f64 f64) (result i32) + get_local 0 + get_local 1 + f64.ge + get_local 0 + get_local 1 + f64.lt + i32.or) + (export \"f32.no_trichotomy_lt\" (func 0)) + (export \"f32.no_trichotomy_le\" (func 1)) + (export \"f32.no_trichotomy_gt\" (func 2)) + (export \"f32.no_trichotomy_ge\" (func 3)) + (export \"f64.no_trichotomy_lt\" (func 4)) + (export \"f64.no_trichotomy_le\" (func 5)) + (export \"f64.no_trichotomy_gt\" (func 6)) + (export \"f64.no_trichotomy_ge\" (func 7))) + "; + 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_87(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 2238 +fn c821_l2238_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c821_l2238_action_invoke"); + let result = instance.call("f32.no_trichotomy_lt", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2239 +fn c822_l2239_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c822_l2239_action_invoke"); + let result = instance.call("f32.no_trichotomy_le", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2240 +fn c823_l2240_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c823_l2240_action_invoke"); + let result = instance.call("f32.no_trichotomy_gt", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2241 +fn c824_l2241_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c824_l2241_action_invoke"); + let result = instance.call("f32.no_trichotomy_ge", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2242 +fn c825_l2242_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c825_l2242_action_invoke"); + let result = instance.call("f64.no_trichotomy_lt", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2243 +fn c826_l2243_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c826_l2243_action_invoke"); + let result = instance.call("f64.no_trichotomy_le", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2244 +fn c827_l2244_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c827_l2244_action_invoke"); + let result = instance.call("f64.no_trichotomy_gt", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2245 +fn c828_l2245_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c828_l2245_action_invoke"); + let result = instance.call("f64.no_trichotomy_ge", &[Value::F64((0.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2250 + +#[test] +fn test_module_87() { + let mut instance = create_module_87(); + // We group the calls together + start_module_87(&mut instance); + c821_l2238_action_invoke(&mut instance); + c822_l2239_action_invoke(&mut instance); + c823_l2240_action_invoke(&mut instance); + c824_l2241_action_invoke(&mut instance); + c825_l2242_action_invoke(&mut instance); + c826_l2243_action_invoke(&mut instance); + c827_l2244_action_invoke(&mut instance); + c828_l2245_action_invoke(&mut instance); +} +fn create_module_88() -> Box { + let module_str = "(module + (type (;0;) (func (param i32 i32) (result i32))) + (type (;1;) (func (param i32) (result i32))) + (type (;2;) (func (param i64 i64) (result i64))) + (type (;3;) (func (param i64) (result i64))) + (func (;0;) (type 0) (param i32 i32) (result i32) + get_local 0 + f32.reinterpret/i32 + get_local 1 + f32.reinterpret/i32 + f32.div + i32.reinterpret/f32 + i32.const 2143289344 + i32.and) + (func (;1;) (type 0) (param i32 i32) (result i32) + get_local 0 + f32.reinterpret/i32 + get_local 1 + f32.reinterpret/i32 + f32.div + i32.reinterpret/f32 + i32.const 2147483647 + i32.and) + (func (;2;) (type 1) (param i32) (result i32) + get_local 0 + f32.reinterpret/i32 + f32.neg + i32.reinterpret/f32) + (func (;3;) (type 2) (param i64 i64) (result i64) + get_local 0 + f64.reinterpret/i64 + get_local 1 + f64.reinterpret/i64 + f64.div + i64.reinterpret/f64 + i64.const 9221120237041090560 + i64.and) + (func (;4;) (type 2) (param i64 i64) (result i64) + get_local 0 + f64.reinterpret/i64 + get_local 1 + f64.reinterpret/i64 + f64.div + i64.reinterpret/f64 + i64.const 9223372036854775807 + i64.and) + (func (;5;) (type 3) (param i64) (result i64) + get_local 0 + f64.reinterpret/i64 + f64.neg + i64.reinterpret/f64) + (func (;6;) (type 1) (param i32) (result i32) + get_local 0 + f32.reinterpret/i32 + f32.const 0x0p+0 (;=0;) + f32.sub + i32.reinterpret/f32 + i32.const 2143289344 + i32.and) + (func (;7;) (type 1) (param i32) (result i32) + f32.const -0x0p+0 (;=-0;) + get_local 0 + f32.reinterpret/i32 + f32.sub + i32.reinterpret/f32 + i32.const 2143289344 + i32.and) + (func (;8;) (type 1) (param i32) (result i32) + get_local 0 + f32.reinterpret/i32 + f32.const 0x1p+0 (;=1;) + f32.mul + i32.reinterpret/f32 + i32.const 2143289344 + i32.and) + (func (;9;) (type 1) (param i32) (result i32) + f32.const -0x1p+0 (;=-1;) + get_local 0 + f32.reinterpret/i32 + f32.mul + i32.reinterpret/f32 + i32.const 2143289344 + i32.and) + (func (;10;) (type 1) (param i32) (result i32) + get_local 0 + f32.reinterpret/i32 + f32.const 0x1p+0 (;=1;) + f32.div + i32.reinterpret/f32 + i32.const 2143289344 + i32.and) + (func (;11;) (type 1) (param i32) (result i32) + get_local 0 + f32.reinterpret/i32 + f32.const -0x1p+0 (;=-1;) + f32.div + i32.reinterpret/f32 + i32.const 2143289344 + i32.and) + (func (;12;) (type 3) (param i64) (result i64) + get_local 0 + f64.reinterpret/i64 + f64.const 0x0p+0 (;=0;) + f64.sub + i64.reinterpret/f64 + i64.const 9221120237041090560 + i64.and) + (func (;13;) (type 3) (param i64) (result i64) + f64.const -0x0p+0 (;=-0;) + get_local 0 + f64.reinterpret/i64 + f64.sub + i64.reinterpret/f64 + i64.const 9221120237041090560 + i64.and) + (func (;14;) (type 3) (param i64) (result i64) + get_local 0 + f64.reinterpret/i64 + f64.const 0x1p+0 (;=1;) + f64.mul + i64.reinterpret/f64 + i64.const 9221120237041090560 + i64.and) + (func (;15;) (type 3) (param i64) (result i64) + f64.const -0x1p+0 (;=-1;) + get_local 0 + f64.reinterpret/i64 + f64.mul + i64.reinterpret/f64 + i64.const 9221120237041090560 + i64.and) + (func (;16;) (type 3) (param i64) (result i64) + get_local 0 + f64.reinterpret/i64 + f64.const 0x1p+0 (;=1;) + f64.div + i64.reinterpret/f64 + i64.const 9221120237041090560 + i64.and) + (func (;17;) (type 3) (param i64) (result i64) + get_local 0 + f64.reinterpret/i64 + f64.const -0x1p+0 (;=-1;) + f64.div + i64.reinterpret/f64 + i64.const 9221120237041090560 + i64.and) + (func (;18;) (type 1) (param i32) (result i32) + get_local 0 + f32.reinterpret/i32 + f64.promote/f32 + f32.demote/f64 + i32.reinterpret/f32 + i32.const 2143289344 + i32.and) + (export \"f32.arithmetic_nan_bitpattern\" (func 0)) + (export \"f32.canonical_nan_bitpattern\" (func 1)) + (export \"f32.nonarithmetic_nan_bitpattern\" (func 2)) + (export \"f64.arithmetic_nan_bitpattern\" (func 3)) + (export \"f64.canonical_nan_bitpattern\" (func 4)) + (export \"f64.nonarithmetic_nan_bitpattern\" (func 5)) + (export \"f32.no_fold_sub_zero\" (func 6)) + (export \"f32.no_fold_neg0_sub\" (func 7)) + (export \"f32.no_fold_mul_one\" (func 8)) + (export \"f32.no_fold_neg1_mul\" (func 9)) + (export \"f32.no_fold_div_one\" (func 10)) + (export \"f32.no_fold_div_neg1\" (func 11)) + (export \"f64.no_fold_sub_zero\" (func 12)) + (export \"f64.no_fold_neg0_sub\" (func 13)) + (export \"f64.no_fold_mul_one\" (func 14)) + (export \"f64.no_fold_neg1_mul\" (func 15)) + (export \"f64.no_fold_div_one\" (func 16)) + (export \"f64.no_fold_div_neg1\" (func 17)) + (export \"no_fold_promote_demote\" (func 18))) + "; + 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_88(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 2329 +fn c830_l2329_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c830_l2329_action_invoke"); + let result = instance.call("f32.arithmetic_nan_bitpattern", &[Value::I32(2139107856 as i32), Value::I32(2139107856 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2143289344 as i32)))); + result.map(|_| ()) +} + +// Line 2330 +fn c831_l2330_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c831_l2330_action_invoke"); + let result = instance.call("f32.canonical_nan_bitpattern", &[Value::I32(0 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2143289344 as i32)))); + result.map(|_| ()) +} + +// Line 2331 +fn c832_l2331_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c832_l2331_action_invoke"); + let result = instance.call("f32.canonical_nan_bitpattern", &[Value::I32(2143289344 as i32), Value::I32(2143289344 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2143289344 as i32)))); + result.map(|_| ()) +} + +// Line 2332 +fn c833_l2332_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c833_l2332_action_invoke"); + let result = instance.call("f32.canonical_nan_bitpattern", &[Value::I32(-4194304 as i32), Value::I32(2143289344 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2143289344 as i32)))); + result.map(|_| ()) +} + +// Line 2333 +fn c834_l2333_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c834_l2333_action_invoke"); + let result = instance.call("f32.canonical_nan_bitpattern", &[Value::I32(2143289344 as i32), Value::I32(-4194304 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2143289344 as i32)))); + result.map(|_| ()) +} + +// Line 2334 +fn c835_l2334_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c835_l2334_action_invoke"); + let result = instance.call("f32.canonical_nan_bitpattern", &[Value::I32(-4194304 as i32), Value::I32(-4194304 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2143289344 as i32)))); + result.map(|_| ()) +} + +// Line 2335 +fn c836_l2335_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c836_l2335_action_invoke"); + let result = instance.call("f32.nonarithmetic_nan_bitpattern", &[Value::I32(2143302160 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-4181488 as i32)))); + result.map(|_| ()) +} + +// Line 2336 +fn c837_l2336_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c837_l2336_action_invoke"); + let result = instance.call("f32.nonarithmetic_nan_bitpattern", &[Value::I32(-4181488 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2143302160 as i32)))); + result.map(|_| ()) +} + +// Line 2337 +fn c838_l2337_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c838_l2337_action_invoke"); + let result = instance.call("f32.nonarithmetic_nan_bitpattern", &[Value::I32(2139107856 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-8375792 as i32)))); + result.map(|_| ()) +} + +// Line 2338 +fn c839_l2338_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c839_l2338_action_invoke"); + let result = instance.call("f32.nonarithmetic_nan_bitpattern", &[Value::I32(-8375792 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2139107856 as i32)))); + result.map(|_| ()) +} + +// Line 2339 +fn c840_l2339_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c840_l2339_action_invoke"); + let result = instance.call("f64.arithmetic_nan_bitpattern", &[Value::I64(9218868437227418128 as i64), Value::I64(9218868437227418128 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(9221120237041090560 as i64)))); + result.map(|_| ()) +} + +// Line 2340 +fn c841_l2340_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c841_l2340_action_invoke"); + let result = instance.call("f64.canonical_nan_bitpattern", &[Value::I64(0 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(9221120237041090560 as i64)))); + result.map(|_| ()) +} + +// Line 2341 +fn c842_l2341_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c842_l2341_action_invoke"); + let result = instance.call("f64.canonical_nan_bitpattern", &[Value::I64(9221120237041090560 as i64), Value::I64(9221120237041090560 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(9221120237041090560 as i64)))); + result.map(|_| ()) +} + +// Line 2342 +fn c843_l2342_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c843_l2342_action_invoke"); + let result = instance.call("f64.canonical_nan_bitpattern", &[Value::I64(-2251799813685248 as i64), Value::I64(9221120237041090560 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(9221120237041090560 as i64)))); + result.map(|_| ()) +} + +// Line 2343 +fn c844_l2343_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c844_l2343_action_invoke"); + let result = instance.call("f64.canonical_nan_bitpattern", &[Value::I64(9221120237041090560 as i64), Value::I64(-2251799813685248 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(9221120237041090560 as i64)))); + result.map(|_| ()) +} + +// Line 2344 +fn c845_l2344_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c845_l2344_action_invoke"); + let result = instance.call("f64.canonical_nan_bitpattern", &[Value::I64(-2251799813685248 as i64), Value::I64(-2251799813685248 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(9221120237041090560 as i64)))); + result.map(|_| ()) +} + +// Line 2345 +fn c846_l2345_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c846_l2345_action_invoke"); + let result = instance.call("f64.nonarithmetic_nan_bitpattern", &[Value::I64(9221120237041103376 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-2251799813672432 as i64)))); + result.map(|_| ()) +} + +// Line 2346 +fn c847_l2346_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c847_l2346_action_invoke"); + let result = instance.call("f64.nonarithmetic_nan_bitpattern", &[Value::I64(-2251799813672432 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(9221120237041103376 as i64)))); + result.map(|_| ()) +} + +// Line 2347 +fn c848_l2347_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c848_l2347_action_invoke"); + let result = instance.call("f64.nonarithmetic_nan_bitpattern", &[Value::I64(9218868437227418128 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-4503599627357680 as i64)))); + result.map(|_| ()) +} + +// Line 2348 +fn c849_l2348_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c849_l2348_action_invoke"); + let result = instance.call("f64.nonarithmetic_nan_bitpattern", &[Value::I64(-4503599627357680 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(9218868437227418128 as i64)))); + result.map(|_| ()) +} + +// Line 2349 +fn c850_l2349_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c850_l2349_action_invoke"); + let result = instance.call("f32.no_fold_sub_zero", &[Value::I32(2141192192 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2143289344 as i32)))); + result.map(|_| ()) +} + +// Line 2350 +fn c851_l2350_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c851_l2350_action_invoke"); + let result = instance.call("f32.no_fold_neg0_sub", &[Value::I32(2141192192 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2143289344 as i32)))); + result.map(|_| ()) +} + +// Line 2351 +fn c852_l2351_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c852_l2351_action_invoke"); + let result = instance.call("f32.no_fold_mul_one", &[Value::I32(2141192192 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2143289344 as i32)))); + result.map(|_| ()) +} + +// Line 2352 +fn c853_l2352_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c853_l2352_action_invoke"); + let result = instance.call("f32.no_fold_neg1_mul", &[Value::I32(2141192192 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2143289344 as i32)))); + result.map(|_| ()) +} + +// Line 2353 +fn c854_l2353_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c854_l2353_action_invoke"); + let result = instance.call("f32.no_fold_div_one", &[Value::I32(2141192192 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2143289344 as i32)))); + result.map(|_| ()) +} + +// Line 2354 +fn c855_l2354_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c855_l2354_action_invoke"); + let result = instance.call("f32.no_fold_div_neg1", &[Value::I32(2141192192 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2143289344 as i32)))); + result.map(|_| ()) +} + +// Line 2355 +fn c856_l2355_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c856_l2355_action_invoke"); + let result = instance.call("f64.no_fold_sub_zero", &[Value::I64(9219994337134247936 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(9221120237041090560 as i64)))); + result.map(|_| ()) +} + +// Line 2356 +fn c857_l2356_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c857_l2356_action_invoke"); + let result = instance.call("f64.no_fold_neg0_sub", &[Value::I64(9219994337134247936 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(9221120237041090560 as i64)))); + result.map(|_| ()) +} + +// Line 2357 +fn c858_l2357_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c858_l2357_action_invoke"); + let result = instance.call("f64.no_fold_mul_one", &[Value::I64(9219994337134247936 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(9221120237041090560 as i64)))); + result.map(|_| ()) +} + +// Line 2358 +fn c859_l2358_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c859_l2358_action_invoke"); + let result = instance.call("f64.no_fold_neg1_mul", &[Value::I64(9219994337134247936 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(9221120237041090560 as i64)))); + result.map(|_| ()) +} + +// Line 2359 +fn c860_l2359_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c860_l2359_action_invoke"); + let result = instance.call("f64.no_fold_div_one", &[Value::I64(9219994337134247936 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(9221120237041090560 as i64)))); + result.map(|_| ()) +} + +// Line 2360 +fn c861_l2360_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c861_l2360_action_invoke"); + let result = instance.call("f64.no_fold_div_neg1", &[Value::I64(9219994337134247936 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(9221120237041090560 as i64)))); + result.map(|_| ()) +} + +// Line 2361 +fn c862_l2361_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c862_l2361_action_invoke"); + let result = instance.call("no_fold_promote_demote", &[Value::I32(2141192192 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2143289344 as i32)))); + result.map(|_| ()) +} + +// Line 2366 + +#[test] +fn test_module_88() { + let mut instance = create_module_88(); + // We group the calls together + start_module_88(&mut instance); + c830_l2329_action_invoke(&mut instance); + c831_l2330_action_invoke(&mut instance); + c832_l2331_action_invoke(&mut instance); + c833_l2332_action_invoke(&mut instance); + c834_l2333_action_invoke(&mut instance); + c835_l2334_action_invoke(&mut instance); + c836_l2335_action_invoke(&mut instance); + c837_l2336_action_invoke(&mut instance); + c838_l2337_action_invoke(&mut instance); + c839_l2338_action_invoke(&mut instance); + c840_l2339_action_invoke(&mut instance); + c841_l2340_action_invoke(&mut instance); + c842_l2341_action_invoke(&mut instance); + c843_l2342_action_invoke(&mut instance); + c844_l2343_action_invoke(&mut instance); + c845_l2344_action_invoke(&mut instance); + c846_l2345_action_invoke(&mut instance); + c847_l2346_action_invoke(&mut instance); + c848_l2347_action_invoke(&mut instance); + c849_l2348_action_invoke(&mut instance); + c850_l2349_action_invoke(&mut instance); + c851_l2350_action_invoke(&mut instance); + c852_l2351_action_invoke(&mut instance); + c853_l2352_action_invoke(&mut instance); + c854_l2353_action_invoke(&mut instance); + c855_l2354_action_invoke(&mut instance); + c856_l2355_action_invoke(&mut instance); + c857_l2356_action_invoke(&mut instance); + c858_l2357_action_invoke(&mut instance); + c859_l2358_action_invoke(&mut instance); + c860_l2359_action_invoke(&mut instance); + c861_l2360_action_invoke(&mut instance); + c862_l2361_action_invoke(&mut instance); +} +fn create_module_89() -> Box { + let module_str = "(module + (type (;0;) (func (param f64 f64 f64 f64 f64 f64 f64 f64) (result f64))) + (func (;0;) (type 0) (param f64 f64 f64 f64 f64 f64 f64 f64) (result f64) + get_local 0 + get_local 4 + f64.mul + get_local 1 + get_local 5 + f64.mul + f64.add + get_local 2 + get_local 6 + f64.mul + f64.add + get_local 3 + get_local 7 + f64.mul + f64.add) + (func (;1;) (type 0) (param f64 f64 f64 f64 f64 f64 f64 f64) (result f64) + get_local 0 + get_local 4 + f64.mul + get_local 1 + get_local 5 + f64.mul + f64.add + get_local 2 + get_local 6 + f64.mul + get_local 3 + get_local 7 + f64.mul + f64.add + f64.add) + (export \"dot_product_example\" (func 0)) + (export \"with_binary_sum_collapse\" (func 1))) + "; + 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_89(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 2389 +fn c864_l2389_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c864_l2389_action_invoke"); + let result = instance.call("dot_product_example", &[Value::F64((32000000.0f64).to_bits()), Value::F64((1.0f64).to_bits()), Value::F64((-1.0f64).to_bits()), Value::F64((80000000.0f64).to_bits()), Value::F64((40000000.0f64).to_bits()), Value::F64((1.0f64).to_bits()), Value::F64((-1.0f64).to_bits()), Value::F64((-16000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((2.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2393 +fn c865_l2393_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c865_l2393_action_invoke"); + let result = instance.call("with_binary_sum_collapse", &[Value::F64((32000000.0f64).to_bits()), Value::F64((1.0f64).to_bits()), Value::F64((-1.0f64).to_bits()), Value::F64((80000000.0f64).to_bits()), Value::F64((40000000.0f64).to_bits()), Value::F64((1.0f64).to_bits()), Value::F64((-1.0f64).to_bits()), Value::F64((-16000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((2.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2400 + +#[test] +fn test_module_89() { + let mut instance = create_module_89(); + // We group the calls together + start_module_89(&mut instance); + c864_l2389_action_invoke(&mut instance); + c865_l2393_action_invoke(&mut instance); +} +fn create_module_90() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32) (result f32))) + (type (;1;) (func (param f64 f64) (result f64))) + (func (;0;) (type 0) (param f32 f32) (result f32) + get_local 0 + get_local 0 + f32.mul + get_local 1 + get_local 1 + f32.mul + f32.sub + f32.sqrt) + (func (;1;) (type 1) (param f64 f64) (result f64) + get_local 0 + get_local 0 + f64.mul + get_local 1 + get_local 1 + f64.mul + f64.sub + f64.sqrt) + (export \"f32.contract2fma\" (func 0)) + (export \"f64.contract2fma\" (func 1))) + "; + 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_90(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 2411 +fn c867_l2411_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c867_l2411_action_invoke"); + let result = instance.call("f32.contract2fma", &[Value::F32((1.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2412 +fn c868_l2412_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c868_l2412_action_invoke"); + let result = instance.call("f32.contract2fma", &[Value::F32((1.1f32).to_bits()), Value::F32((1.1f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2413 +fn c869_l2413_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c869_l2413_action_invoke"); + let result = instance.call("f32.contract2fma", &[Value::F32((1.1999999f32).to_bits()), Value::F32((1.1999999f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2414 +fn c870_l2414_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c870_l2414_action_invoke"); + let result = instance.call("f64.contract2fma", &[Value::F64((1.0f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2415 +fn c871_l2415_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c871_l2415_action_invoke"); + let result = instance.call("f64.contract2fma", &[Value::F64((1.1f64).to_bits()), Value::F64((1.1f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2416 +fn c872_l2416_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c872_l2416_action_invoke"); + let result = instance.call("f64.contract2fma", &[Value::F64((1.2f64).to_bits()), Value::F64((1.2f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2421 + +#[test] +fn test_module_90() { + let mut instance = create_module_90(); + // We group the calls together + start_module_90(&mut instance); + c867_l2411_action_invoke(&mut instance); + c868_l2412_action_invoke(&mut instance); + c869_l2413_action_invoke(&mut instance); + c870_l2414_action_invoke(&mut instance); + c871_l2415_action_invoke(&mut instance); + c872_l2416_action_invoke(&mut instance); +} +fn create_module_91() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32 f32) (result f32))) + (type (;1;) (func (param f64 f64 f64) (result f64))) + (func (;0;) (type 0) (param f32 f32 f32) (result f32) + get_local 0 + get_local 1 + get_local 2 + f32.div + f32.sub) + (func (;1;) (type 1) (param f64 f64 f64) (result f64) + get_local 0 + get_local 1 + get_local 2 + f64.div + f64.sub) + (export \"f32.division_by_small_number\" (func 0)) + (export \"f64.division_by_small_number\" (func 1))) + "; + 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_91(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 2430 +fn c874_l2430_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c874_l2430_action_invoke"); + let result = instance.call("f32.division_by_small_number", &[Value::F32((112000000.0f32).to_bits()), Value::F32((100000.0f32).to_bits()), Value::F32((0.0009f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((888888.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2431 +fn c875_l2431_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c875_l2431_action_invoke"); + let result = instance.call("f64.division_by_small_number", &[Value::F64((112000000.0f64).to_bits()), Value::F64((100000.0f64).to_bits()), Value::F64((0.0009f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((888888.8888888806f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2436 + +#[test] +fn test_module_91() { + let mut instance = create_module_91(); + // We group the calls together + start_module_91(&mut instance); + c874_l2430_action_invoke(&mut instance); + c875_l2431_action_invoke(&mut instance); +} +fn create_module_92() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32 f32) (result f32))) + (type (;1;) (func (param f64 f64 f64) (result f64))) + (func (;0;) (type 0) (param f32 f32 f32) (result f32) + get_local 0 + get_local 1 + get_local 2 + f32.sqrt + f32.add + f32.mul) + (func (;1;) (type 1) (param f64 f64 f64) (result f64) + get_local 0 + get_local 1 + get_local 2 + f64.sqrt + f64.add + f64.mul) + (export \"f32.golden_ratio\" (func 0)) + (export \"f64.golden_ratio\" (func 1))) + "; + 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_92(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 2443 +fn c877_l2443_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c877_l2443_action_invoke"); + let result = instance.call("f32.golden_ratio", &[Value::F32((0.5f32).to_bits()), Value::F32((1.0f32).to_bits()), Value::F32((5.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.618034f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2444 +fn c878_l2444_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c878_l2444_action_invoke"); + let result = instance.call("f64.golden_ratio", &[Value::F64((0.5f64).to_bits()), Value::F64((1.0f64).to_bits()), Value::F64((5.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.618033988749895f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2449 + +#[test] +fn test_module_92() { + let mut instance = create_module_92(); + // We group the calls together + start_module_92(&mut instance); + c877_l2443_action_invoke(&mut instance); + c878_l2444_action_invoke(&mut instance); +} +fn create_module_93() -> Box { + let module_str = "(module + (type (;0;) (func (param f32) (result f32))) + (type (;1;) (func (param f64) (result f64))) + (func (;0;) (type 0) (param f32) (result f32) + f32.const 0x1p-1 (;=0.5;) + get_local 0 + get_local 0 + get_local 0 + f32.mul + f32.const 0x1p+2 (;=4;) + f32.add + f32.sqrt + f32.add + f32.mul) + (func (;1;) (type 1) (param f64) (result f64) + f64.const 0x1p-1 (;=0.5;) + get_local 0 + get_local 0 + get_local 0 + f64.mul + f64.const 0x1p+2 (;=4;) + f64.add + f64.sqrt + f64.add + f64.mul) + (export \"f32.silver_means\" (func 0)) + (export \"f64.silver_means\" (func 1))) + "; + 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_93(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 2462 +fn c880_l2462_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c880_l2462_action_invoke"); + let result = instance.call("f32.silver_means", &[Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2463 +fn c881_l2463_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c881_l2463_action_invoke"); + let result = instance.call("f32.silver_means", &[Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.618034f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2464 +fn c882_l2464_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c882_l2464_action_invoke"); + let result = instance.call("f32.silver_means", &[Value::F32((2.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((2.4142137f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2465 +fn c883_l2465_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c883_l2465_action_invoke"); + let result = instance.call("f32.silver_means", &[Value::F32((3.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((3.3027756f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2466 +fn c884_l2466_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c884_l2466_action_invoke"); + let result = instance.call("f32.silver_means", &[Value::F32((4.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((4.236068f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2467 +fn c885_l2467_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c885_l2467_action_invoke"); + let result = instance.call("f32.silver_means", &[Value::F32((5.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((5.192582f32).to_bits())))); + result.map(|_| ()) +} + +// Line 2468 +fn c886_l2468_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c886_l2468_action_invoke"); + let result = instance.call("f64.silver_means", &[Value::F64((0.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2469 +fn c887_l2469_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c887_l2469_action_invoke"); + let result = instance.call("f64.silver_means", &[Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.618033988749895f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2470 +fn c888_l2470_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c888_l2470_action_invoke"); + let result = instance.call("f64.silver_means", &[Value::F64((2.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((2.414213562373095f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2471 +fn c889_l2471_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c889_l2471_action_invoke"); + let result = instance.call("f64.silver_means", &[Value::F64((3.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((3.302775637731995f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2472 +fn c890_l2472_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c890_l2472_action_invoke"); + let result = instance.call("f64.silver_means", &[Value::F64((4.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((4.23606797749979f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2473 +fn c891_l2473_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c891_l2473_action_invoke"); + let result = instance.call("f64.silver_means", &[Value::F64((5.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((5.192582403567252f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2478 + +#[test] +fn test_module_93() { + let mut instance = create_module_93(); + // We group the calls together + start_module_93(&mut instance); + c880_l2462_action_invoke(&mut instance); + c881_l2463_action_invoke(&mut instance); + c882_l2464_action_invoke(&mut instance); + c883_l2465_action_invoke(&mut instance); + c884_l2466_action_invoke(&mut instance); + c885_l2467_action_invoke(&mut instance); + c886_l2468_action_invoke(&mut instance); + c887_l2469_action_invoke(&mut instance); + c888_l2470_action_invoke(&mut instance); + c889_l2471_action_invoke(&mut instance); + c890_l2472_action_invoke(&mut instance); + c891_l2473_action_invoke(&mut instance); +} +fn create_module_94() -> Box { + let module_str = "(module + (type (;0;) (func (param f64 f64) (result i32))) + (func (;0;) (type 0) (param f64 f64) (result i32) + get_local 0 + get_local 1 + f64.div + f64.const 0x1.999999999999ap-2 (;=0.4;) + f64.lt) + (export \"point_four\" (func 0))) + "; + 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_94(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 2483 +fn c893_l2483_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c893_l2483_action_invoke"); + let result = instance.call("point_four", &[Value::F64((4.0f64).to_bits()), Value::F64((10.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 2488 + +#[test] +fn test_module_94() { + let mut instance = create_module_94(); + // We group the calls together + start_module_94(&mut instance); + c893_l2483_action_invoke(&mut instance); +} +fn create_module_95() -> Box { + let module_str = "(module + (type (;0;) (func (param i32) (result f64))) + (func (;0;) (type 0) (param i32) (result f64) + (local f64 f64 f64 f64) + f64.const 0x0p+0 (;=0;) + set_local 1 + block ;; label = @1 + get_local 0 + i32.const 1 + i32.lt_s + br_if 0 (;@1;) + f64.const 0x1p+0 (;=1;) + set_local 2 + f64.const 0x0p+0 (;=0;) + set_local 3 + loop ;; label = @2 + get_local 1 + get_local 2 + f64.const 0x1p+3 (;=8;) + get_local 3 + f64.const 0x1p+3 (;=8;) + f64.mul + tee_local 4 + f64.const 0x1p+0 (;=1;) + f64.add + f64.div + f64.const 0x1p+2 (;=4;) + get_local 4 + f64.const 0x1p+2 (;=4;) + f64.add + f64.div + f64.sub + f64.const 0x1p+1 (;=2;) + get_local 4 + f64.const 0x1.4p+2 (;=5;) + f64.add + f64.div + f64.sub + f64.const 0x1p+1 (;=2;) + get_local 4 + f64.const 0x1.8p+2 (;=6;) + f64.add + f64.div + f64.sub + f64.mul + f64.add + set_local 1 + get_local 3 + f64.const 0x1p+0 (;=1;) + f64.add + set_local 3 + get_local 2 + f64.const 0x1p-4 (;=0.0625;) + f64.mul + set_local 2 + get_local 0 + i32.const -1 + i32.add + tee_local 0 + br_if 0 (;@2;) + end + end + get_local 1) + (export \"tau\" (func 0))) + "; + 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_95(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 2553 +fn c895_l2553_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c895_l2553_action_invoke"); + let result = instance.call("tau", &[Value::I32(10 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179583f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2554 +fn c896_l2554_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c896_l2554_action_invoke"); + let result = instance.call("tau", &[Value::I32(11 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((6.283185307179586f64).to_bits())))); + result.map(|_| ()) +} + +// Line 2558 + +#[test] +fn test_module_95() { + let mut instance = create_module_95(); + // We group the calls together + start_module_95(&mut instance); + c895_l2553_action_invoke(&mut instance); + c896_l2554_action_invoke(&mut instance); +} +fn create_module_96() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32) (result f32))) + (type (;1;) (func (param f64 f64) (result f64))) + (func (;0;) (type 0) (param f32 f32) (result f32) + get_local 0 + get_local 0 + f32.const 0x1p+0 (;=1;) + f32.add + get_local 1 + f32.const 0x0p+0 (;=0;) + f32.lt + select) + (func (;1;) (type 1) (param f64 f64) (result f64) + get_local 0 + get_local 0 + f64.const 0x1p+0 (;=1;) + f64.add + get_local 1 + f64.const 0x0p+0 (;=0;) + f64.lt + select) + (export \"f32.no_fold_conditional_inc\" (func 0)) + (export \"f64.no_fold_conditional_inc\" (func 1))) + "; + 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_96(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 2569 +fn c898_l2569_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c898_l2569_action_invoke"); + let result = instance.call("f32.no_fold_conditional_inc", &[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 2570 +fn c899_l2570_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c899_l2570_action_invoke"); + let result = instance.call("f64.no_fold_conditional_inc", &[Value::F64((-0.0f64).to_bits()), Value::F64((-1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +#[test] +fn test_module_96() { + let mut instance = create_module_96(); + // We group the calls together + start_module_96(&mut instance); + c898_l2569_action_invoke(&mut instance); + c899_l2570_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/float_literals.rs b/lib/runtime/tests/spectests/float_literals.rs new file mode 100644 index 000000000..f2509ec95 --- /dev/null +++ b/lib/runtime/tests/spectests/float_literals.rs @@ -0,0 +1,1732 @@ +// 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/float_literals.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 3 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func (result i32))) + (type (;1;) (func (result i64))) + (type (;2;) (func (result f32))) + (type (;3;) (func (result f64))) + (func (;0;) (type 0) (result i32) + f32.const nan (;=nan;) + i32.reinterpret/f32) + (func (;1;) (type 0) (result i32) + f32.const nan (;=nan;) + i32.reinterpret/f32) + (func (;2;) (type 0) (result i32) + f32.const -nan (;=nan;) + i32.reinterpret/f32) + (func (;3;) (type 0) (result i32) + f32.const nan (;=nan;) + i32.reinterpret/f32) + (func (;4;) (type 0) (result i32) + f32.const nan:0x200000 (;=nan;) + i32.reinterpret/f32) + (func (;5;) (type 0) (result i32) + f32.const -nan:0x7fffff (;=nan;) + i32.reinterpret/f32) + (func (;6;) (type 0) (result i32) + f32.const nan:0x12345 (;=nan;) + i32.reinterpret/f32) + (func (;7;) (type 0) (result i32) + f32.const nan:0x304050 (;=nan;) + i32.reinterpret/f32) + (func (;8;) (type 0) (result i32) + f32.const -nan:0x2abcde (;=nan;) + i32.reinterpret/f32) + (func (;9;) (type 0) (result i32) + f32.const inf (;=inf;) + i32.reinterpret/f32) + (func (;10;) (type 0) (result i32) + f32.const inf (;=inf;) + i32.reinterpret/f32) + (func (;11;) (type 0) (result i32) + f32.const -inf (;=-inf;) + i32.reinterpret/f32) + (func (;12;) (type 0) (result i32) + f32.const 0x0p+0 (;=0;) + i32.reinterpret/f32) + (func (;13;) (type 0) (result i32) + f32.const 0x0p+0 (;=0;) + i32.reinterpret/f32) + (func (;14;) (type 0) (result i32) + f32.const -0x0p+0 (;=-0;) + i32.reinterpret/f32) + (func (;15;) (type 0) (result i32) + f32.const 0x1.921fb6p+2 (;=6.28319;) + i32.reinterpret/f32) + (func (;16;) (type 0) (result i32) + f32.const 0x1.p-149 (;=1.4013e-45;) + i32.reinterpret/f32) + (func (;17;) (type 0) (result i32) + f32.const 0x1p-126 (;=1.17549e-38;) + i32.reinterpret/f32) + (func (;18;) (type 0) (result i32) + f32.const 0x1.fffffep+127 (;=3.40282e+38;) + i32.reinterpret/f32) + (func (;19;) (type 0) (result i32) + f32.const 0x1.fffffcp-127 (;=1.17549e-38;) + i32.reinterpret/f32) + (func (;20;) (type 0) (result i32) + f32.const 0x1p+10 (;=1024;) + i32.reinterpret/f32) + (func (;21;) (type 0) (result i32) + f32.const 0x0p+0 (;=0;) + i32.reinterpret/f32) + (func (;22;) (type 0) (result i32) + f32.const 0x0p+0 (;=0;) + i32.reinterpret/f32) + (func (;23;) (type 0) (result i32) + f32.const -0x0p+0 (;=-0;) + i32.reinterpret/f32) + (func (;24;) (type 0) (result i32) + f32.const 0x1.921fb6p+2 (;=6.28319;) + i32.reinterpret/f32) + (func (;25;) (type 0) (result i32) + f32.const 0x1.p-149 (;=1.4013e-45;) + i32.reinterpret/f32) + (func (;26;) (type 0) (result i32) + f32.const 0x1p-126 (;=1.17549e-38;) + i32.reinterpret/f32) + (func (;27;) (type 0) (result i32) + f32.const 0x1.fffffcp-127 (;=1.17549e-38;) + i32.reinterpret/f32) + (func (;28;) (type 0) (result i32) + f32.const 0x1.fffffep+127 (;=3.40282e+38;) + i32.reinterpret/f32) + (func (;29;) (type 0) (result i32) + f32.const 0x1.2a05f2p+33 (;=1e+10;) + i32.reinterpret/f32) + (func (;30;) (type 0) (result i32) + f32.const 0x1.000002p+0 (;=1;) + i32.reinterpret/f32) + (func (;31;) (type 1) (result i64) + f64.const nan (;=nan;) + i64.reinterpret/f64) + (func (;32;) (type 1) (result i64) + f64.const nan (;=nan;) + i64.reinterpret/f64) + (func (;33;) (type 1) (result i64) + f64.const -nan (;=nan;) + i64.reinterpret/f64) + (func (;34;) (type 1) (result i64) + f64.const nan (;=nan;) + i64.reinterpret/f64) + (func (;35;) (type 1) (result i64) + f64.const nan:0x4000000000000 (;=nan;) + i64.reinterpret/f64) + (func (;36;) (type 1) (result i64) + f64.const -nan:0xfffffffffffff (;=nan;) + i64.reinterpret/f64) + (func (;37;) (type 1) (result i64) + f64.const nan:0x123456789abc (;=nan;) + i64.reinterpret/f64) + (func (;38;) (type 1) (result i64) + f64.const nan:0x3040506070809 (;=nan;) + i64.reinterpret/f64) + (func (;39;) (type 1) (result i64) + f64.const -nan:0x2abcdef012345 (;=nan;) + i64.reinterpret/f64) + (func (;40;) (type 1) (result i64) + f64.const inf (;=inf;) + i64.reinterpret/f64) + (func (;41;) (type 1) (result i64) + f64.const inf (;=inf;) + i64.reinterpret/f64) + (func (;42;) (type 1) (result i64) + f64.const -inf (;=-inf;) + i64.reinterpret/f64) + (func (;43;) (type 1) (result i64) + f64.const 0x0p+0 (;=0;) + i64.reinterpret/f64) + (func (;44;) (type 1) (result i64) + f64.const 0x0p+0 (;=0;) + i64.reinterpret/f64) + (func (;45;) (type 1) (result i64) + f64.const -0x0p+0 (;=-0;) + i64.reinterpret/f64) + (func (;46;) (type 1) (result i64) + f64.const 0x1.921fb54442d18p+2 (;=6.28319;) + i64.reinterpret/f64) + (func (;47;) (type 1) (result i64) + f64.const 0x1.p-1074 (;=4.94066e-324;) + i64.reinterpret/f64) + (func (;48;) (type 1) (result i64) + f64.const 0x1p-1022 (;=2.22507e-308;) + i64.reinterpret/f64) + (func (;49;) (type 1) (result i64) + f64.const 0x1.ffffffffffffep-1023 (;=2.22507e-308;) + i64.reinterpret/f64) + (func (;50;) (type 1) (result i64) + f64.const 0x1.fffffffffffffp+1023 (;=1.79769e+308;) + i64.reinterpret/f64) + (func (;51;) (type 1) (result i64) + f64.const 0x1p+100 (;=1.26765e+30;) + i64.reinterpret/f64) + (func (;52;) (type 1) (result i64) + f64.const 0x0p+0 (;=0;) + i64.reinterpret/f64) + (func (;53;) (type 1) (result i64) + f64.const 0x0p+0 (;=0;) + i64.reinterpret/f64) + (func (;54;) (type 1) (result i64) + f64.const -0x0p+0 (;=-0;) + i64.reinterpret/f64) + (func (;55;) (type 1) (result i64) + f64.const 0x1.921fb54442d18p+2 (;=6.28319;) + i64.reinterpret/f64) + (func (;56;) (type 1) (result i64) + f64.const 0x1.p-1074 (;=4.94066e-324;) + i64.reinterpret/f64) + (func (;57;) (type 1) (result i64) + f64.const 0x1p-1022 (;=2.22507e-308;) + i64.reinterpret/f64) + (func (;58;) (type 1) (result i64) + f64.const 0x1.ffffffffffffep-1023 (;=2.22507e-308;) + i64.reinterpret/f64) + (func (;59;) (type 1) (result i64) + f64.const 0x1.fffffffffffffp+1023 (;=1.79769e+308;) + i64.reinterpret/f64) + (func (;60;) (type 1) (result i64) + f64.const 0x1.249ad2594c37dp+332 (;=1e+100;) + i64.reinterpret/f64) + (func (;61;) (type 1) (result i64) + f64.const 0x1.000001ff19e24p+0 (;=1;) + i64.reinterpret/f64) + (func (;62;) (type 2) (result f32) + f32.const 0x1.e848p+19 (;=1e+06;)) + (func (;63;) (type 2) (result f32) + f32.const 0x1.f4p+9 (;=1000;)) + (func (;64;) (type 2) (result f32) + f32.const 0x1.f5922p+9 (;=1003.14;)) + (func (;65;) (type 2) (result f32) + f32.const 0x1.c2332cp+49 (;=9.9e+14;)) + (func (;66;) (type 2) (result f32) + f32.const 0x1.3b5ce8p+93 (;=1.22e+28;)) + (func (;67;) (type 2) (result f32) + f32.const 0x1.41e014p+27 (;=1.68755e+08;)) + (func (;68;) (type 2) (result f32) + f32.const 0x1.aa0fp+16 (;=109071;)) + (func (;69;) (type 2) (result f32) + f32.const 0x1.41ffe2p+15 (;=41215.9;)) + (func (;70;) (type 2) (result f32) + f32.const 0x1.ep+20 (;=1.96608e+06;)) + (func (;71;) (type 2) (result f32) + f32.const 0x1.57805p+44 (;=2.36052e+13;)) + (func (;72;) (type 3) (result f64) + f64.const 0x1.e848p+19 (;=1e+06;)) + (func (;73;) (type 3) (result f64) + f64.const 0x1.f4p+9 (;=1000;)) + (func (;74;) (type 3) (result f64) + f64.const 0x1.f5921fafc8bp+9 (;=1003.14;)) + (func (;75;) (type 3) (result f64) + f64.const 0x1.05c735bb7cc45p-402 (;=9.9e-122;)) + (func (;76;) (type 3) (result f64) + f64.const 0x1.3b5ce725bde9cp+93 (;=1.22e+28;)) + (func (;77;) (type 3) (result f64) + f64.const 0x1.5e01e00013332p+51 (;=3.0787e+15;)) + (func (;78;) (type 3) (result f64) + f64.const 0x1.aa0fp+16 (;=109071;)) + (func (;79;) (type 3) (result f64) + f64.const 0x1.41ffe2834b34p+15 (;=41215.9;)) + (func (;80;) (type 3) (result f64) + f64.const 0x1.ep+20 (;=1.96608e+06;)) + (func (;81;) (type 3) (result f64) + f64.const 0x1.578050f9f7p+44 (;=2.36052e+13;)) + (export \"f32.nan\" (func 0)) + (export \"f32.positive_nan\" (func 1)) + (export \"f32.negative_nan\" (func 2)) + (export \"f32.plain_nan\" (func 3)) + (export \"f32.informally_known_as_plain_snan\" (func 4)) + (export \"f32.all_ones_nan\" (func 5)) + (export \"f32.misc_nan\" (func 6)) + (export \"f32.misc_positive_nan\" (func 7)) + (export \"f32.misc_negative_nan\" (func 8)) + (export \"f32.infinity\" (func 9)) + (export \"f32.positive_infinity\" (func 10)) + (export \"f32.negative_infinity\" (func 11)) + (export \"f32.zero\" (func 12)) + (export \"f32.positive_zero\" (func 13)) + (export \"f32.negative_zero\" (func 14)) + (export \"f32.misc\" (func 15)) + (export \"f32.min_positive\" (func 16)) + (export \"f32.min_normal\" (func 17)) + (export \"f32.max_finite\" (func 18)) + (export \"f32.max_subnormal\" (func 19)) + (export \"f32.trailing_dot\" (func 20)) + (export \"f32_dec.zero\" (func 21)) + (export \"f32_dec.positive_zero\" (func 22)) + (export \"f32_dec.negative_zero\" (func 23)) + (export \"f32_dec.misc\" (func 24)) + (export \"f32_dec.min_positive\" (func 25)) + (export \"f32_dec.min_normal\" (func 26)) + (export \"f32_dec.max_subnormal\" (func 27)) + (export \"f32_dec.max_finite\" (func 28)) + (export \"f32_dec.trailing_dot\" (func 29)) + (export \"f32_dec.root_beer_float\" (func 30)) + (export \"f64.nan\" (func 31)) + (export \"f64.positive_nan\" (func 32)) + (export \"f64.negative_nan\" (func 33)) + (export \"f64.plain_nan\" (func 34)) + (export \"f64.informally_known_as_plain_snan\" (func 35)) + (export \"f64.all_ones_nan\" (func 36)) + (export \"f64.misc_nan\" (func 37)) + (export \"f64.misc_positive_nan\" (func 38)) + (export \"f64.misc_negative_nan\" (func 39)) + (export \"f64.infinity\" (func 40)) + (export \"f64.positive_infinity\" (func 41)) + (export \"f64.negative_infinity\" (func 42)) + (export \"f64.zero\" (func 43)) + (export \"f64.positive_zero\" (func 44)) + (export \"f64.negative_zero\" (func 45)) + (export \"f64.misc\" (func 46)) + (export \"f64.min_positive\" (func 47)) + (export \"f64.min_normal\" (func 48)) + (export \"f64.max_subnormal\" (func 49)) + (export \"f64.max_finite\" (func 50)) + (export \"f64.trailing_dot\" (func 51)) + (export \"f64_dec.zero\" (func 52)) + (export \"f64_dec.positive_zero\" (func 53)) + (export \"f64_dec.negative_zero\" (func 54)) + (export \"f64_dec.misc\" (func 55)) + (export \"f64_dec.min_positive\" (func 56)) + (export \"f64_dec.min_normal\" (func 57)) + (export \"f64_dec.max_subnormal\" (func 58)) + (export \"f64_dec.max_finite\" (func 59)) + (export \"f64_dec.trailing_dot\" (func 60)) + (export \"f64_dec.root_beer_float\" (func 61)) + (export \"f32-dec-sep1\" (func 62)) + (export \"f32-dec-sep2\" (func 63)) + (export \"f32-dec-sep3\" (func 64)) + (export \"f32-dec-sep4\" (func 65)) + (export \"f32-dec-sep5\" (func 66)) + (export \"f32-hex-sep1\" (func 67)) + (export \"f32-hex-sep2\" (func 68)) + (export \"f32-hex-sep3\" (func 69)) + (export \"f32-hex-sep4\" (func 70)) + (export \"f32-hex-sep5\" (func 71)) + (export \"f64-dec-sep1\" (func 72)) + (export \"f64-dec-sep2\" (func 73)) + (export \"f64-dec-sep3\" (func 74)) + (export \"f64-dec-sep4\" (func 75)) + (export \"f64-dec-sep5\" (func 76)) + (export \"f64-hex-sep1\" (func 77)) + (export \"f64-hex-sep2\" (func 78)) + (export \"f64-hex-sep3\" (func 79)) + (export \"f64-hex-sep4\" (func 80)) + (export \"f64-hex-sep5\" (func 81))) + "; + 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 105 +fn c1_l105_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l105_action_invoke"); + let result = instance.call("f32.nan", &[]); + assert_eq!(result, Ok(Some(Value::I32(2143289344 as i32)))); + result.map(|_| ()) +} + +// Line 106 +fn c2_l106_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l106_action_invoke"); + let result = instance.call("f32.positive_nan", &[]); + assert_eq!(result, Ok(Some(Value::I32(2143289344 as i32)))); + result.map(|_| ()) +} + +// Line 107 +fn c3_l107_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l107_action_invoke"); + let result = instance.call("f32.negative_nan", &[]); + assert_eq!(result, Ok(Some(Value::I32(-4194304 as i32)))); + result.map(|_| ()) +} + +// Line 108 +fn c4_l108_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l108_action_invoke"); + let result = instance.call("f32.plain_nan", &[]); + assert_eq!(result, Ok(Some(Value::I32(2143289344 as i32)))); + result.map(|_| ()) +} + +// Line 109 +fn c5_l109_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l109_action_invoke"); + let result = instance.call("f32.informally_known_as_plain_snan", &[]); + assert_eq!(result, Ok(Some(Value::I32(2141192192 as i32)))); + result.map(|_| ()) +} + +// Line 110 +fn c6_l110_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l110_action_invoke"); + let result = instance.call("f32.all_ones_nan", &[]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 111 +fn c7_l111_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l111_action_invoke"); + let result = instance.call("f32.misc_nan", &[]); + assert_eq!(result, Ok(Some(Value::I32(2139169605 as i32)))); + result.map(|_| ()) +} + +// Line 112 +fn c8_l112_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l112_action_invoke"); + let result = instance.call("f32.misc_positive_nan", &[]); + assert_eq!(result, Ok(Some(Value::I32(2142257232 as i32)))); + result.map(|_| ()) +} + +// Line 113 +fn c9_l113_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l113_action_invoke"); + let result = instance.call("f32.misc_negative_nan", &[]); + assert_eq!(result, Ok(Some(Value::I32(-5587746 as i32)))); + result.map(|_| ()) +} + +// Line 114 +fn c10_l114_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c10_l114_action_invoke"); + let result = instance.call("f32.infinity", &[]); + assert_eq!(result, Ok(Some(Value::I32(2139095040 as i32)))); + result.map(|_| ()) +} + +// Line 115 +fn c11_l115_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c11_l115_action_invoke"); + let result = instance.call("f32.positive_infinity", &[]); + assert_eq!(result, Ok(Some(Value::I32(2139095040 as i32)))); + result.map(|_| ()) +} + +// Line 116 +fn c12_l116_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c12_l116_action_invoke"); + let result = instance.call("f32.negative_infinity", &[]); + assert_eq!(result, Ok(Some(Value::I32(-8388608 as i32)))); + result.map(|_| ()) +} + +// Line 117 +fn c13_l117_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c13_l117_action_invoke"); + let result = instance.call("f32.zero", &[]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 118 +fn c14_l118_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c14_l118_action_invoke"); + let result = instance.call("f32.positive_zero", &[]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 119 +fn c15_l119_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c15_l119_action_invoke"); + let result = instance.call("f32.negative_zero", &[]); + assert_eq!(result, Ok(Some(Value::I32(-2147483648 as i32)))); + result.map(|_| ()) +} + +// Line 120 +fn c16_l120_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c16_l120_action_invoke"); + let result = instance.call("f32.misc", &[]); + assert_eq!(result, Ok(Some(Value::I32(1086918619 as i32)))); + result.map(|_| ()) +} + +// Line 121 +fn c17_l121_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c17_l121_action_invoke"); + let result = instance.call("f32.min_positive", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 122 +fn c18_l122_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c18_l122_action_invoke"); + let result = instance.call("f32.min_normal", &[]); + assert_eq!(result, Ok(Some(Value::I32(8388608 as i32)))); + result.map(|_| ()) +} + +// Line 123 +fn c19_l123_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c19_l123_action_invoke"); + let result = instance.call("f32.max_subnormal", &[]); + assert_eq!(result, Ok(Some(Value::I32(8388607 as i32)))); + result.map(|_| ()) +} + +// Line 124 +fn c20_l124_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c20_l124_action_invoke"); + let result = instance.call("f32.max_finite", &[]); + assert_eq!(result, Ok(Some(Value::I32(2139095039 as i32)))); + result.map(|_| ()) +} + +// Line 125 +fn c21_l125_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c21_l125_action_invoke"); + let result = instance.call("f32.trailing_dot", &[]); + assert_eq!(result, Ok(Some(Value::I32(1149239296 as i32)))); + result.map(|_| ()) +} + +// Line 126 +fn c22_l126_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c22_l126_action_invoke"); + let result = instance.call("f32_dec.zero", &[]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 127 +fn c23_l127_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c23_l127_action_invoke"); + let result = instance.call("f32_dec.positive_zero", &[]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 128 +fn c24_l128_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c24_l128_action_invoke"); + let result = instance.call("f32_dec.negative_zero", &[]); + assert_eq!(result, Ok(Some(Value::I32(-2147483648 as i32)))); + result.map(|_| ()) +} + +// Line 129 +fn c25_l129_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c25_l129_action_invoke"); + let result = instance.call("f32_dec.misc", &[]); + assert_eq!(result, Ok(Some(Value::I32(1086918619 as i32)))); + result.map(|_| ()) +} + +// Line 130 +fn c26_l130_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c26_l130_action_invoke"); + let result = instance.call("f32_dec.min_positive", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 131 +fn c27_l131_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c27_l131_action_invoke"); + let result = instance.call("f32_dec.min_normal", &[]); + assert_eq!(result, Ok(Some(Value::I32(8388608 as i32)))); + result.map(|_| ()) +} + +// Line 132 +fn c28_l132_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c28_l132_action_invoke"); + let result = instance.call("f32_dec.max_subnormal", &[]); + assert_eq!(result, Ok(Some(Value::I32(8388607 as i32)))); + result.map(|_| ()) +} + +// Line 133 +fn c29_l133_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c29_l133_action_invoke"); + let result = instance.call("f32_dec.max_finite", &[]); + assert_eq!(result, Ok(Some(Value::I32(2139095039 as i32)))); + result.map(|_| ()) +} + +// Line 134 +fn c30_l134_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c30_l134_action_invoke"); + let result = instance.call("f32_dec.trailing_dot", &[]); + assert_eq!(result, Ok(Some(Value::I32(1343554297 as i32)))); + result.map(|_| ()) +} + +// Line 135 +fn c31_l135_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c31_l135_action_invoke"); + let result = instance.call("f32_dec.root_beer_float", &[]); + assert_eq!(result, Ok(Some(Value::I32(1065353217 as i32)))); + result.map(|_| ()) +} + +// Line 137 +fn c32_l137_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c32_l137_action_invoke"); + let result = instance.call("f64.nan", &[]); + assert_eq!(result, Ok(Some(Value::I64(9221120237041090560 as i64)))); + result.map(|_| ()) +} + +// Line 138 +fn c33_l138_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c33_l138_action_invoke"); + let result = instance.call("f64.positive_nan", &[]); + assert_eq!(result, Ok(Some(Value::I64(9221120237041090560 as i64)))); + result.map(|_| ()) +} + +// Line 139 +fn c34_l139_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c34_l139_action_invoke"); + let result = instance.call("f64.negative_nan", &[]); + assert_eq!(result, Ok(Some(Value::I64(-2251799813685248 as i64)))); + result.map(|_| ()) +} + +// Line 140 +fn c35_l140_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c35_l140_action_invoke"); + let result = instance.call("f64.plain_nan", &[]); + assert_eq!(result, Ok(Some(Value::I64(9221120237041090560 as i64)))); + result.map(|_| ()) +} + +// Line 141 +fn c36_l141_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c36_l141_action_invoke"); + let result = instance.call("f64.informally_known_as_plain_snan", &[]); + assert_eq!(result, Ok(Some(Value::I64(9219994337134247936 as i64)))); + result.map(|_| ()) +} + +// Line 142 +fn c37_l142_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c37_l142_action_invoke"); + let result = instance.call("f64.all_ones_nan", &[]); + assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); + result.map(|_| ()) +} + +// Line 143 +fn c38_l143_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c38_l143_action_invoke"); + let result = instance.call("f64.misc_nan", &[]); + assert_eq!(result, Ok(Some(Value::I64(9218888453225749180 as i64)))); + result.map(|_| ()) +} + +// Line 144 +fn c39_l144_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c39_l144_action_invoke"); + let result = instance.call("f64.misc_positive_nan", &[]); + assert_eq!(result, Ok(Some(Value::I64(9219717281780008969 as i64)))); + result.map(|_| ()) +} + +// Line 145 +fn c40_l145_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c40_l145_action_invoke"); + let result = instance.call("f64.misc_negative_nan", &[]); + assert_eq!(result, Ok(Some(Value::I64(-3751748707474619 as i64)))); + result.map(|_| ()) +} + +// Line 146 +fn c41_l146_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c41_l146_action_invoke"); + let result = instance.call("f64.infinity", &[]); + assert_eq!(result, Ok(Some(Value::I64(9218868437227405312 as i64)))); + result.map(|_| ()) +} + +// Line 147 +fn c42_l147_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c42_l147_action_invoke"); + let result = instance.call("f64.positive_infinity", &[]); + assert_eq!(result, Ok(Some(Value::I64(9218868437227405312 as i64)))); + result.map(|_| ()) +} + +// Line 148 +fn c43_l148_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c43_l148_action_invoke"); + let result = instance.call("f64.negative_infinity", &[]); + assert_eq!(result, Ok(Some(Value::I64(-4503599627370496 as i64)))); + result.map(|_| ()) +} + +// Line 149 +fn c44_l149_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c44_l149_action_invoke"); + let result = instance.call("f64.zero", &[]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 150 +fn c45_l150_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c45_l150_action_invoke"); + let result = instance.call("f64.positive_zero", &[]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 151 +fn c46_l151_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c46_l151_action_invoke"); + let result = instance.call("f64.negative_zero", &[]); + assert_eq!(result, Ok(Some(Value::I64(-9223372036854775808 as i64)))); + result.map(|_| ()) +} + +// Line 152 +fn c47_l152_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c47_l152_action_invoke"); + let result = instance.call("f64.misc", &[]); + assert_eq!(result, Ok(Some(Value::I64(4618760256179416344 as i64)))); + result.map(|_| ()) +} + +// Line 153 +fn c48_l153_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c48_l153_action_invoke"); + let result = instance.call("f64.min_positive", &[]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 154 +fn c49_l154_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c49_l154_action_invoke"); + let result = instance.call("f64.min_normal", &[]); + assert_eq!(result, Ok(Some(Value::I64(4503599627370496 as i64)))); + result.map(|_| ()) +} + +// Line 155 +fn c50_l155_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c50_l155_action_invoke"); + let result = instance.call("f64.max_subnormal", &[]); + assert_eq!(result, Ok(Some(Value::I64(4503599627370495 as i64)))); + result.map(|_| ()) +} + +// Line 156 +fn c51_l156_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c51_l156_action_invoke"); + let result = instance.call("f64.max_finite", &[]); + assert_eq!(result, Ok(Some(Value::I64(9218868437227405311 as i64)))); + result.map(|_| ()) +} + +// Line 157 +fn c52_l157_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c52_l157_action_invoke"); + let result = instance.call("f64.trailing_dot", &[]); + assert_eq!(result, Ok(Some(Value::I64(5057542381537067008 as i64)))); + result.map(|_| ()) +} + +// Line 158 +fn c53_l158_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c53_l158_action_invoke"); + let result = instance.call("f64_dec.zero", &[]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 159 +fn c54_l159_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c54_l159_action_invoke"); + let result = instance.call("f64_dec.positive_zero", &[]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 160 +fn c55_l160_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c55_l160_action_invoke"); + let result = instance.call("f64_dec.negative_zero", &[]); + assert_eq!(result, Ok(Some(Value::I64(-9223372036854775808 as i64)))); + result.map(|_| ()) +} + +// Line 161 +fn c56_l161_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c56_l161_action_invoke"); + let result = instance.call("f64_dec.misc", &[]); + assert_eq!(result, Ok(Some(Value::I64(4618760256179416344 as i64)))); + result.map(|_| ()) +} + +// Line 162 +fn c57_l162_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c57_l162_action_invoke"); + let result = instance.call("f64_dec.min_positive", &[]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 163 +fn c58_l163_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c58_l163_action_invoke"); + let result = instance.call("f64_dec.min_normal", &[]); + assert_eq!(result, Ok(Some(Value::I64(4503599627370496 as i64)))); + result.map(|_| ()) +} + +// Line 164 +fn c59_l164_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c59_l164_action_invoke"); + let result = instance.call("f64_dec.max_subnormal", &[]); + assert_eq!(result, Ok(Some(Value::I64(4503599627370495 as i64)))); + result.map(|_| ()) +} + +// Line 165 +fn c60_l165_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c60_l165_action_invoke"); + let result = instance.call("f64_dec.max_finite", &[]); + assert_eq!(result, Ok(Some(Value::I64(9218868437227405311 as i64)))); + result.map(|_| ()) +} + +// Line 166 +fn c61_l166_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c61_l166_action_invoke"); + let result = instance.call("f64_dec.trailing_dot", &[]); + assert_eq!(result, Ok(Some(Value::I64(6103021453049119613 as i64)))); + result.map(|_| ()) +} + +// Line 167 +fn c62_l167_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c62_l167_action_invoke"); + let result = instance.call("f64_dec.root_beer_float", &[]); + assert_eq!(result, Ok(Some(Value::I64(4607182419335945764 as i64)))); + result.map(|_| ()) +} + +// Line 169 +fn c63_l169_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c63_l169_action_invoke"); + let result = instance.call("f32-dec-sep1", &[]); + assert_eq!(result, Ok(Some(Value::F32((1000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 170 +fn c64_l170_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c64_l170_action_invoke"); + let result = instance.call("f32-dec-sep2", &[]); + assert_eq!(result, Ok(Some(Value::F32((1000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 171 +fn c65_l171_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c65_l171_action_invoke"); + let result = instance.call("f32-dec-sep3", &[]); + assert_eq!(result, Ok(Some(Value::F32((1003.1416f32).to_bits())))); + result.map(|_| ()) +} + +// Line 172 +fn c66_l172_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c66_l172_action_invoke"); + let result = instance.call("f32-dec-sep4", &[]); + assert_eq!(result, Ok(Some(Value::F32((990000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 173 +fn c67_l173_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c67_l173_action_invoke"); + let result = instance.call("f32-dec-sep5", &[]); + assert_eq!(result, Ok(Some(Value::F32((12200012000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 174 +fn c68_l174_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c68_l174_action_invoke"); + let result = instance.call("f32-hex-sep1", &[]); + assert_eq!(result, Ok(Some(Value::F32((168755360.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 175 +fn c69_l175_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c69_l175_action_invoke"); + let result = instance.call("f32-hex-sep2", &[]); + assert_eq!(result, Ok(Some(Value::F32((109071.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 176 +fn c70_l176_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c70_l176_action_invoke"); + let result = instance.call("f32-hex-sep3", &[]); + assert_eq!(result, Ok(Some(Value::F32((41215.94f32).to_bits())))); + result.map(|_| ()) +} + +// Line 177 +fn c71_l177_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c71_l177_action_invoke"); + let result = instance.call("f32-hex-sep4", &[]); + assert_eq!(result, Ok(Some(Value::F32((1966080.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 178 +fn c72_l178_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c72_l178_action_invoke"); + let result = instance.call("f32-hex-sep5", &[]); + assert_eq!(result, Ok(Some(Value::F32((23605224000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 180 +fn c73_l180_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c73_l180_action_invoke"); + let result = instance.call("f64-dec-sep1", &[]); + assert_eq!(result, Ok(Some(Value::F64((1000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 181 +fn c74_l181_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c74_l181_action_invoke"); + let result = instance.call("f64-dec-sep2", &[]); + assert_eq!(result, Ok(Some(Value::F64((1000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 182 +fn c75_l182_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c75_l182_action_invoke"); + let result = instance.call("f64-dec-sep3", &[]); + assert_eq!(result, Ok(Some(Value::F64((1003.141592f64).to_bits())))); + result.map(|_| ()) +} + +// Line 183 +fn c76_l183_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c76_l183_action_invoke"); + let result = instance.call("f64-dec-sep4", &[]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000099f64).to_bits())))); + result.map(|_| ()) +} + +// Line 184 +fn c77_l184_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c77_l184_action_invoke"); + let result = instance.call("f64-dec-sep5", &[]); + assert_eq!(result, Ok(Some(Value::F64((12200011354000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 185 +fn c78_l185_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c78_l185_action_invoke"); + let result = instance.call("f64-hex-sep1", &[]); + assert_eq!(result, Ok(Some(Value::F64((3078696982321561.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 186 +fn c79_l186_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c79_l186_action_invoke"); + let result = instance.call("f64-hex-sep2", &[]); + assert_eq!(result, Ok(Some(Value::F64((109071.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 187 +fn c80_l187_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c80_l187_action_invoke"); + let result = instance.call("f64-hex-sep3", &[]); + assert_eq!(result, Ok(Some(Value::F64((41215.94240794191f64).to_bits())))); + result.map(|_| ()) +} + +// Line 188 +fn c81_l188_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c81_l188_action_invoke"); + let result = instance.call("f64-hex-sep4", &[]); + assert_eq!(result, Ok(Some(Value::F64((1966080.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 189 +fn c82_l189_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c82_l189_action_invoke"); + let result = instance.call("f64-hex-sep5", &[]); + assert_eq!(result, Ok(Some(Value::F64((23605225168752.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 192 + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l105_action_invoke(&mut instance); + c2_l106_action_invoke(&mut instance); + c3_l107_action_invoke(&mut instance); + c4_l108_action_invoke(&mut instance); + c5_l109_action_invoke(&mut instance); + c6_l110_action_invoke(&mut instance); + c7_l111_action_invoke(&mut instance); + c8_l112_action_invoke(&mut instance); + c9_l113_action_invoke(&mut instance); + c10_l114_action_invoke(&mut instance); + c11_l115_action_invoke(&mut instance); + c12_l116_action_invoke(&mut instance); + c13_l117_action_invoke(&mut instance); + c14_l118_action_invoke(&mut instance); + c15_l119_action_invoke(&mut instance); + c16_l120_action_invoke(&mut instance); + c17_l121_action_invoke(&mut instance); + c18_l122_action_invoke(&mut instance); + c19_l123_action_invoke(&mut instance); + c20_l124_action_invoke(&mut instance); + c21_l125_action_invoke(&mut instance); + c22_l126_action_invoke(&mut instance); + c23_l127_action_invoke(&mut instance); + c24_l128_action_invoke(&mut instance); + c25_l129_action_invoke(&mut instance); + c26_l130_action_invoke(&mut instance); + c27_l131_action_invoke(&mut instance); + c28_l132_action_invoke(&mut instance); + c29_l133_action_invoke(&mut instance); + c30_l134_action_invoke(&mut instance); + c31_l135_action_invoke(&mut instance); + c32_l137_action_invoke(&mut instance); + c33_l138_action_invoke(&mut instance); + c34_l139_action_invoke(&mut instance); + c35_l140_action_invoke(&mut instance); + c36_l141_action_invoke(&mut instance); + c37_l142_action_invoke(&mut instance); + c38_l143_action_invoke(&mut instance); + c39_l144_action_invoke(&mut instance); + c40_l145_action_invoke(&mut instance); + c41_l146_action_invoke(&mut instance); + c42_l147_action_invoke(&mut instance); + c43_l148_action_invoke(&mut instance); + c44_l149_action_invoke(&mut instance); + c45_l150_action_invoke(&mut instance); + c46_l151_action_invoke(&mut instance); + c47_l152_action_invoke(&mut instance); + c48_l153_action_invoke(&mut instance); + c49_l154_action_invoke(&mut instance); + c50_l155_action_invoke(&mut instance); + c51_l156_action_invoke(&mut instance); + c52_l157_action_invoke(&mut instance); + c53_l158_action_invoke(&mut instance); + c54_l159_action_invoke(&mut instance); + c55_l160_action_invoke(&mut instance); + c56_l161_action_invoke(&mut instance); + c57_l162_action_invoke(&mut instance); + c58_l163_action_invoke(&mut instance); + c59_l164_action_invoke(&mut instance); + c60_l165_action_invoke(&mut instance); + c61_l166_action_invoke(&mut instance); + c62_l167_action_invoke(&mut instance); + c63_l169_action_invoke(&mut instance); + c64_l170_action_invoke(&mut instance); + c65_l171_action_invoke(&mut instance); + c66_l172_action_invoke(&mut instance); + c67_l173_action_invoke(&mut instance); + c68_l174_action_invoke(&mut instance); + c69_l175_action_invoke(&mut instance); + c70_l176_action_invoke(&mut instance); + c71_l177_action_invoke(&mut instance); + c72_l178_action_invoke(&mut instance); + c73_l180_action_invoke(&mut instance); + c74_l181_action_invoke(&mut instance); + c75_l182_action_invoke(&mut instance); + c76_l183_action_invoke(&mut instance); + c77_l184_action_invoke(&mut instance); + c78_l185_action_invoke(&mut instance); + c79_l186_action_invoke(&mut instance); + c80_l187_action_invoke(&mut instance); + c81_l188_action_invoke(&mut instance); + c82_l189_action_invoke(&mut instance); +} +fn create_module_2() -> Box { + let module_str = "(module + (type (;0;) (func (result f64))) + (func (;0;) (type 0) (result f64) + f64.const 0x1.ffffffa2p+31 (;=4.29497e+09;)) + (export \"4294967249\" (func 0))) + "; + 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_2(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 201 +fn c84_l201_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c84_l201_action_invoke"); + let result = instance.call("4294967249", &[]); + assert_eq!(result, Ok(Some(Value::F64((4294967249.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 204 +#[test] +fn c85_l204_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 95, 49, 48, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 208 +#[test] +fn c86_l208_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 43, 95, 49, 48, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 212 +#[test] +fn c87_l212_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 45, 95, 49, 48, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 216 +#[test] +fn c88_l216_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 57, 57, 95, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 220 +#[test] +fn c89_l220_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 49, 95, 95, 48, 48, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 224 +#[test] +fn c90_l224_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 95, 49, 46, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 228 +#[test] +fn c91_l228_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 49, 46, 48, 95, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 232 +#[test] +fn c92_l232_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 49, 95, 46, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 236 +#[test] +fn c93_l236_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 49, 46, 95, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 240 +#[test] +fn c94_l240_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 95, 49, 101, 49, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 244 +#[test] +fn c95_l244_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 49, 101, 49, 95, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 248 +#[test] +fn c96_l248_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 49, 95, 101, 49, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 252 +#[test] +fn c97_l252_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 49, 101, 95, 49, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 256 +#[test] +fn c98_l256_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 95, 49, 46, 48, 101, 49, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 260 +#[test] +fn c99_l260_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 49, 46, 48, 101, 49, 95, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 264 +#[test] +fn c100_l264_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 49, 46, 48, 95, 101, 49, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 268 +#[test] +fn c101_l268_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 49, 46, 48, 101, 95, 49, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 272 +#[test] +fn c102_l272_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 49, 46, 48, 101, 43, 95, 49, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 276 +#[test] +fn c103_l276_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 49, 46, 48, 101, 95, 43, 49, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 280 +#[test] +fn c104_l280_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 95, 48, 120, 49, 48, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 284 +#[test] +fn c105_l284_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 95, 120, 49, 48, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 288 +#[test] +fn c106_l288_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 95, 49, 48, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 292 +#[test] +fn c107_l292_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 48, 48, 95, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 296 +#[test] +fn c108_l296_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 102, 102, 95, 95, 102, 102, 102, 102, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 300 +#[test] +fn c109_l300_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 95, 49, 46, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 304 +#[test] +fn c110_l304_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 46, 48, 95, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 308 +#[test] +fn c111_l308_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 95, 46, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 312 +#[test] +fn c112_l312_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 46, 95, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 316 +#[test] +fn c113_l316_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 95, 49, 112, 49, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 320 +#[test] +fn c114_l320_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 112, 49, 95, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 324 +#[test] +fn c115_l324_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 95, 112, 49, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 328 +#[test] +fn c116_l328_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 112, 95, 49, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 332 +#[test] +fn c117_l332_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 95, 49, 46, 48, 112, 49, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 336 +#[test] +fn c118_l336_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 46, 48, 112, 49, 95, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 340 +#[test] +fn c119_l340_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 46, 48, 95, 112, 49, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 344 +#[test] +fn c120_l344_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 46, 48, 112, 95, 49, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 348 +#[test] +fn c121_l348_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 46, 48, 112, 43, 95, 49, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 352 +#[test] +fn c122_l352_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 51, 50, 32, 40, 102, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 46, 48, 112, 95, 43, 49, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 357 +#[test] +fn c123_l357_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 95, 49, 48, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 361 +#[test] +fn c124_l361_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 43, 95, 49, 48, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 365 +#[test] +fn c125_l365_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 45, 95, 49, 48, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 369 +#[test] +fn c126_l369_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 57, 57, 95, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 373 +#[test] +fn c127_l373_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 49, 95, 95, 48, 48, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 377 +#[test] +fn c128_l377_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 95, 49, 46, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 381 +#[test] +fn c129_l381_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 49, 46, 48, 95, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 385 +#[test] +fn c130_l385_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 49, 95, 46, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 389 +#[test] +fn c131_l389_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 49, 46, 95, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 393 +#[test] +fn c132_l393_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 95, 49, 101, 49, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 397 +#[test] +fn c133_l397_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 49, 101, 49, 95, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 401 +#[test] +fn c134_l401_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 49, 95, 101, 49, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 405 +#[test] +fn c135_l405_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 49, 101, 95, 49, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 409 +#[test] +fn c136_l409_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 95, 49, 46, 48, 101, 49, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 413 +#[test] +fn c137_l413_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 49, 46, 48, 101, 49, 95, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 417 +#[test] +fn c138_l417_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 49, 46, 48, 95, 101, 49, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 421 +#[test] +fn c139_l421_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 49, 46, 48, 101, 95, 49, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 425 +#[test] +fn c140_l425_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 49, 46, 48, 101, 43, 95, 49, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 429 +#[test] +fn c141_l429_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 49, 46, 48, 101, 95, 43, 49, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 433 +#[test] +fn c142_l433_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 95, 48, 120, 49, 48, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 437 +#[test] +fn c143_l437_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 95, 120, 49, 48, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 441 +#[test] +fn c144_l441_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 95, 49, 48, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 445 +#[test] +fn c145_l445_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 48, 48, 95, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 449 +#[test] +fn c146_l449_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 102, 102, 95, 95, 102, 102, 102, 102, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 453 +#[test] +fn c147_l453_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 95, 49, 46, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 457 +#[test] +fn c148_l457_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 46, 48, 95, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 461 +#[test] +fn c149_l461_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 95, 46, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 465 +#[test] +fn c150_l465_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 46, 95, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 469 +#[test] +fn c151_l469_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 95, 49, 112, 49, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 473 +#[test] +fn c152_l473_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 112, 49, 95, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 477 +#[test] +fn c153_l477_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 95, 112, 49, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 481 +#[test] +fn c154_l481_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 112, 95, 49, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 485 +#[test] +fn c155_l485_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 95, 49, 46, 48, 112, 49, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 489 +#[test] +fn c156_l489_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 46, 48, 112, 49, 95, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 493 +#[test] +fn c157_l493_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 46, 48, 95, 112, 49, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 497 +#[test] +fn c158_l497_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 46, 48, 112, 95, 49, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 501 +#[test] +fn c159_l501_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 46, 48, 112, 43, 95, 49, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 505 +#[test] +fn c160_l505_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 102, 54, 52, 32, 40, 102, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 49, 46, 48, 112, 95, 43, 49, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +#[test] +fn test_module_2() { + let mut instance = create_module_2(); + // We group the calls together + start_module_2(&mut instance); + c84_l201_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/float_memory.rs b/lib/runtime/tests/spectests/float_memory.rs new file mode 100644 index 000000000..fbd1894a9 --- /dev/null +++ b/lib/runtime/tests/spectests/float_memory.rs @@ -0,0 +1,1177 @@ +// 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/float_memory.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 5 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func (result f32))) + (type (;1;) (func (result i32))) + (type (;2;) (func)) + (func (;0;) (type 0) (result f32) + i32.const 0 + f32.load) + (func (;1;) (type 1) (result i32) + i32.const 0 + i32.load) + (func (;2;) (type 2) + i32.const 0 + f32.const nan:0x200000 (;=nan;) + f32.store) + (func (;3;) (type 2) + i32.const 0 + i32.const 2141192192 + i32.store) + (func (;4;) (type 2) + i32.const 0 + i32.const 0 + i32.store) + (memory (;0;) 1 1) + (export \"f32.load\" (func 0)) + (export \"i32.load\" (func 1)) + (export \"f32.store\" (func 2)) + (export \"i32.store\" (func 3)) + (export \"reset\" (func 4)) + (data (;0;) (i32.const 0) \"\\00\\00\\a0\\7f\")) + "; + 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 15 +fn c1_l15_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l15_action_invoke"); + let result = instance.call("i32.load", &[]); + assert_eq!(result, Ok(Some(Value::I32(2141192192 as i32)))); + result.map(|_| ()) +} + +// Line 16 +fn c2_l16_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l16_action_invoke"); + let result = instance.call("f32.load", &[]); + let expected = f32::from_bits(2141192192); + 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 17 +fn c3_l17_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l17_action_invoke"); + let result = instance.call("reset", &[]); + + result.map(|_| ()) +} + +// Line 18 +fn c4_l18_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l18_action_invoke"); + let result = instance.call("i32.load", &[]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 19 +fn c5_l19_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l19_action_invoke"); + let result = instance.call("f32.load", &[]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 20 +fn c6_l20_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l20_action_invoke"); + let result = instance.call("f32.store", &[]); + + result.map(|_| ()) +} + +// Line 21 +fn c7_l21_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l21_action_invoke"); + let result = instance.call("i32.load", &[]); + assert_eq!(result, Ok(Some(Value::I32(2141192192 as i32)))); + result.map(|_| ()) +} + +// Line 22 +fn c8_l22_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l22_action_invoke"); + let result = instance.call("f32.load", &[]); + let expected = f32::from_bits(2141192192); + 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 23 +fn c9_l23_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l23_action_invoke"); + let result = instance.call("reset", &[]); + + result.map(|_| ()) +} + +// Line 24 +fn c10_l24_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c10_l24_action_invoke"); + let result = instance.call("i32.load", &[]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 25 +fn c11_l25_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c11_l25_action_invoke"); + let result = instance.call("f32.load", &[]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 26 +fn c12_l26_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c12_l26_action_invoke"); + let result = instance.call("i32.store", &[]); + + result.map(|_| ()) +} + +// Line 27 +fn c13_l27_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c13_l27_action_invoke"); + let result = instance.call("i32.load", &[]); + assert_eq!(result, Ok(Some(Value::I32(2141192192 as i32)))); + result.map(|_| ()) +} + +// Line 28 +fn c14_l28_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c14_l28_action_invoke"); + let result = instance.call("f32.load", &[]); + let expected = f32::from_bits(2141192192); + 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 30 + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l15_action_invoke(&mut instance); + c2_l16_action_invoke(&mut instance); + c3_l17_action_invoke(&mut instance); + c4_l18_action_invoke(&mut instance); + c5_l19_action_invoke(&mut instance); + c6_l20_action_invoke(&mut instance); + c7_l21_action_invoke(&mut instance); + c8_l22_action_invoke(&mut instance); + c9_l23_action_invoke(&mut instance); + c10_l24_action_invoke(&mut instance); + c11_l25_action_invoke(&mut instance); + c12_l26_action_invoke(&mut instance); + c13_l27_action_invoke(&mut instance); + c14_l28_action_invoke(&mut instance); +} +fn create_module_2() -> Box { + let module_str = "(module + (type (;0;) (func (result f64))) + (type (;1;) (func (result i64))) + (type (;2;) (func)) + (func (;0;) (type 0) (result f64) + i32.const 0 + f64.load) + (func (;1;) (type 1) (result i64) + i32.const 0 + i64.load) + (func (;2;) (type 2) + i32.const 0 + f64.const nan:0x4000000000000 (;=nan;) + f64.store) + (func (;3;) (type 2) + i32.const 0 + i64.const 9219994337134247936 + i64.store) + (func (;4;) (type 2) + i32.const 0 + i64.const 0 + i64.store) + (memory (;0;) 1 1) + (export \"f64.load\" (func 0)) + (export \"i64.load\" (func 1)) + (export \"f64.store\" (func 2)) + (export \"i64.store\" (func 3)) + (export \"reset\" (func 4)) + (data (;0;) (i32.const 0) \"\\00\\00\\00\\00\\00\\00\\f4\\7f\")) + "; + 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_2(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 40 +fn c16_l40_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c16_l40_action_invoke"); + let result = instance.call("i64.load", &[]); + assert_eq!(result, Ok(Some(Value::I64(9219994337134247936 as i64)))); + result.map(|_| ()) +} + +// Line 41 +fn c17_l41_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c17_l41_action_invoke"); + let result = instance.call("f64.load", &[]); + let expected = f64::from_bits(9219994337134247936); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 42 +fn c18_l42_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c18_l42_action_invoke"); + let result = instance.call("reset", &[]); + + result.map(|_| ()) +} + +// Line 43 +fn c19_l43_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c19_l43_action_invoke"); + let result = instance.call("i64.load", &[]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 44 +fn c20_l44_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c20_l44_action_invoke"); + let result = instance.call("f64.load", &[]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 45 +fn c21_l45_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c21_l45_action_invoke"); + let result = instance.call("f64.store", &[]); + + result.map(|_| ()) +} + +// Line 46 +fn c22_l46_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c22_l46_action_invoke"); + let result = instance.call("i64.load", &[]); + assert_eq!(result, Ok(Some(Value::I64(9219994337134247936 as i64)))); + result.map(|_| ()) +} + +// Line 47 +fn c23_l47_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c23_l47_action_invoke"); + let result = instance.call("f64.load", &[]); + let expected = f64::from_bits(9219994337134247936); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 48 +fn c24_l48_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c24_l48_action_invoke"); + let result = instance.call("reset", &[]); + + result.map(|_| ()) +} + +// Line 49 +fn c25_l49_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c25_l49_action_invoke"); + let result = instance.call("i64.load", &[]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 50 +fn c26_l50_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c26_l50_action_invoke"); + let result = instance.call("f64.load", &[]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 51 +fn c27_l51_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c27_l51_action_invoke"); + let result = instance.call("i64.store", &[]); + + result.map(|_| ()) +} + +// Line 52 +fn c28_l52_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c28_l52_action_invoke"); + let result = instance.call("i64.load", &[]); + assert_eq!(result, Ok(Some(Value::I64(9219994337134247936 as i64)))); + result.map(|_| ()) +} + +// Line 53 +fn c29_l53_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c29_l53_action_invoke"); + let result = instance.call("f64.load", &[]); + let expected = f64::from_bits(9219994337134247936); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 57 + +#[test] +fn test_module_2() { + let mut instance = create_module_2(); + // We group the calls together + start_module_2(&mut instance); + c16_l40_action_invoke(&mut instance); + c17_l41_action_invoke(&mut instance); + c18_l42_action_invoke(&mut instance); + c19_l43_action_invoke(&mut instance); + c20_l44_action_invoke(&mut instance); + c21_l45_action_invoke(&mut instance); + c22_l46_action_invoke(&mut instance); + c23_l47_action_invoke(&mut instance); + c24_l48_action_invoke(&mut instance); + c25_l49_action_invoke(&mut instance); + c26_l50_action_invoke(&mut instance); + c27_l51_action_invoke(&mut instance); + c28_l52_action_invoke(&mut instance); + c29_l53_action_invoke(&mut instance); +} +fn create_module_3() -> Box { + let module_str = "(module + (type (;0;) (func (result f32))) + (type (;1;) (func (result i32))) + (type (;2;) (func)) + (func (;0;) (type 0) (result f32) + i32.const 1 + f32.load) + (func (;1;) (type 1) (result i32) + i32.const 1 + i32.load) + (func (;2;) (type 2) + i32.const 1 + f32.const nan:0x200000 (;=nan;) + f32.store) + (func (;3;) (type 2) + i32.const 1 + i32.const 2141192192 + i32.store) + (func (;4;) (type 2) + i32.const 1 + i32.const 0 + i32.store) + (memory (;0;) 1 1) + (export \"f32.load\" (func 0)) + (export \"i32.load\" (func 1)) + (export \"f32.store\" (func 2)) + (export \"i32.store\" (func 3)) + (export \"reset\" (func 4)) + (data (;0;) (i32.const 0) \"\\00\\00\\00\\a0\\7f\")) + "; + 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_3(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 67 +fn c31_l67_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c31_l67_action_invoke"); + let result = instance.call("i32.load", &[]); + assert_eq!(result, Ok(Some(Value::I32(2141192192 as i32)))); + result.map(|_| ()) +} + +// Line 68 +fn c32_l68_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c32_l68_action_invoke"); + let result = instance.call("f32.load", &[]); + let expected = f32::from_bits(2141192192); + 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 69 +fn c33_l69_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c33_l69_action_invoke"); + let result = instance.call("reset", &[]); + + result.map(|_| ()) +} + +// Line 70 +fn c34_l70_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c34_l70_action_invoke"); + let result = instance.call("i32.load", &[]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 71 +fn c35_l71_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c35_l71_action_invoke"); + let result = instance.call("f32.load", &[]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 72 +fn c36_l72_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c36_l72_action_invoke"); + let result = instance.call("f32.store", &[]); + + result.map(|_| ()) +} + +// Line 73 +fn c37_l73_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c37_l73_action_invoke"); + let result = instance.call("i32.load", &[]); + assert_eq!(result, Ok(Some(Value::I32(2141192192 as i32)))); + result.map(|_| ()) +} + +// Line 74 +fn c38_l74_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c38_l74_action_invoke"); + let result = instance.call("f32.load", &[]); + let expected = f32::from_bits(2141192192); + 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 75 +fn c39_l75_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c39_l75_action_invoke"); + let result = instance.call("reset", &[]); + + result.map(|_| ()) +} + +// Line 76 +fn c40_l76_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c40_l76_action_invoke"); + let result = instance.call("i32.load", &[]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 77 +fn c41_l77_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c41_l77_action_invoke"); + let result = instance.call("f32.load", &[]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 78 +fn c42_l78_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c42_l78_action_invoke"); + let result = instance.call("i32.store", &[]); + + result.map(|_| ()) +} + +// Line 79 +fn c43_l79_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c43_l79_action_invoke"); + let result = instance.call("i32.load", &[]); + assert_eq!(result, Ok(Some(Value::I32(2141192192 as i32)))); + result.map(|_| ()) +} + +// Line 80 +fn c44_l80_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c44_l80_action_invoke"); + let result = instance.call("f32.load", &[]); + let expected = f32::from_bits(2141192192); + 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 82 + +#[test] +fn test_module_3() { + let mut instance = create_module_3(); + // We group the calls together + start_module_3(&mut instance); + c31_l67_action_invoke(&mut instance); + c32_l68_action_invoke(&mut instance); + c33_l69_action_invoke(&mut instance); + c34_l70_action_invoke(&mut instance); + c35_l71_action_invoke(&mut instance); + c36_l72_action_invoke(&mut instance); + c37_l73_action_invoke(&mut instance); + c38_l74_action_invoke(&mut instance); + c39_l75_action_invoke(&mut instance); + c40_l76_action_invoke(&mut instance); + c41_l77_action_invoke(&mut instance); + c42_l78_action_invoke(&mut instance); + c43_l79_action_invoke(&mut instance); + c44_l80_action_invoke(&mut instance); +} +fn create_module_4() -> Box { + let module_str = "(module + (type (;0;) (func (result f64))) + (type (;1;) (func (result i64))) + (type (;2;) (func)) + (func (;0;) (type 0) (result f64) + i32.const 1 + f64.load) + (func (;1;) (type 1) (result i64) + i32.const 1 + i64.load) + (func (;2;) (type 2) + i32.const 1 + f64.const nan:0x4000000000000 (;=nan;) + f64.store) + (func (;3;) (type 2) + i32.const 1 + i64.const 9219994337134247936 + i64.store) + (func (;4;) (type 2) + i32.const 1 + i64.const 0 + i64.store) + (memory (;0;) 1 1) + (export \"f64.load\" (func 0)) + (export \"i64.load\" (func 1)) + (export \"f64.store\" (func 2)) + (export \"i64.store\" (func 3)) + (export \"reset\" (func 4)) + (data (;0;) (i32.const 0) \"\\00\\00\\00\\00\\00\\00\\00\\f4\\7f\")) + "; + 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_4(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 92 +fn c46_l92_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c46_l92_action_invoke"); + let result = instance.call("i64.load", &[]); + assert_eq!(result, Ok(Some(Value::I64(9219994337134247936 as i64)))); + result.map(|_| ()) +} + +// Line 93 +fn c47_l93_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c47_l93_action_invoke"); + let result = instance.call("f64.load", &[]); + let expected = f64::from_bits(9219994337134247936); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 94 +fn c48_l94_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c48_l94_action_invoke"); + let result = instance.call("reset", &[]); + + result.map(|_| ()) +} + +// Line 95 +fn c49_l95_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c49_l95_action_invoke"); + let result = instance.call("i64.load", &[]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 96 +fn c50_l96_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c50_l96_action_invoke"); + let result = instance.call("f64.load", &[]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 97 +fn c51_l97_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c51_l97_action_invoke"); + let result = instance.call("f64.store", &[]); + + result.map(|_| ()) +} + +// Line 98 +fn c52_l98_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c52_l98_action_invoke"); + let result = instance.call("i64.load", &[]); + assert_eq!(result, Ok(Some(Value::I64(9219994337134247936 as i64)))); + result.map(|_| ()) +} + +// Line 99 +fn c53_l99_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c53_l99_action_invoke"); + let result = instance.call("f64.load", &[]); + let expected = f64::from_bits(9219994337134247936); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 100 +fn c54_l100_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c54_l100_action_invoke"); + let result = instance.call("reset", &[]); + + result.map(|_| ()) +} + +// Line 101 +fn c55_l101_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c55_l101_action_invoke"); + let result = instance.call("i64.load", &[]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 102 +fn c56_l102_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c56_l102_action_invoke"); + let result = instance.call("f64.load", &[]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 103 +fn c57_l103_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c57_l103_action_invoke"); + let result = instance.call("i64.store", &[]); + + result.map(|_| ()) +} + +// Line 104 +fn c58_l104_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c58_l104_action_invoke"); + let result = instance.call("i64.load", &[]); + assert_eq!(result, Ok(Some(Value::I64(9219994337134247936 as i64)))); + result.map(|_| ()) +} + +// Line 105 +fn c59_l105_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c59_l105_action_invoke"); + let result = instance.call("f64.load", &[]); + let expected = f64::from_bits(9219994337134247936); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 109 + +#[test] +fn test_module_4() { + let mut instance = create_module_4(); + // We group the calls together + start_module_4(&mut instance); + c46_l92_action_invoke(&mut instance); + c47_l93_action_invoke(&mut instance); + c48_l94_action_invoke(&mut instance); + c49_l95_action_invoke(&mut instance); + c50_l96_action_invoke(&mut instance); + c51_l97_action_invoke(&mut instance); + c52_l98_action_invoke(&mut instance); + c53_l99_action_invoke(&mut instance); + c54_l100_action_invoke(&mut instance); + c55_l101_action_invoke(&mut instance); + c56_l102_action_invoke(&mut instance); + c57_l103_action_invoke(&mut instance); + c58_l104_action_invoke(&mut instance); + c59_l105_action_invoke(&mut instance); +} +fn create_module_5() -> Box { + let module_str = "(module + (type (;0;) (func (result f32))) + (type (;1;) (func (result i32))) + (type (;2;) (func)) + (func (;0;) (type 0) (result f32) + i32.const 0 + f32.load) + (func (;1;) (type 1) (result i32) + i32.const 0 + i32.load) + (func (;2;) (type 2) + i32.const 0 + f32.const nan:0x500001 (;=nan;) + f32.store) + (func (;3;) (type 2) + i32.const 0 + i32.const 2144337921 + i32.store) + (func (;4;) (type 2) + i32.const 0 + i32.const 0 + i32.store) + (memory (;0;) 1 1) + (export \"f32.load\" (func 0)) + (export \"i32.load\" (func 1)) + (export \"f32.store\" (func 2)) + (export \"i32.store\" (func 3)) + (export \"reset\" (func 4)) + (data (;0;) (i32.const 0) \"\\01\\00\\d0\\7f\")) + "; + 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_5(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 119 +fn c61_l119_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c61_l119_action_invoke"); + let result = instance.call("i32.load", &[]); + assert_eq!(result, Ok(Some(Value::I32(2144337921 as i32)))); + result.map(|_| ()) +} + +// Line 120 +fn c62_l120_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c62_l120_action_invoke"); + let result = instance.call("f32.load", &[]); + let expected = f32::from_bits(2144337921); + 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 121 +fn c63_l121_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c63_l121_action_invoke"); + let result = instance.call("reset", &[]); + + result.map(|_| ()) +} + +// Line 122 +fn c64_l122_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c64_l122_action_invoke"); + let result = instance.call("i32.load", &[]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 123 +fn c65_l123_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c65_l123_action_invoke"); + let result = instance.call("f32.load", &[]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 124 +fn c66_l124_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c66_l124_action_invoke"); + let result = instance.call("f32.store", &[]); + + result.map(|_| ()) +} + +// Line 125 +fn c67_l125_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c67_l125_action_invoke"); + let result = instance.call("i32.load", &[]); + assert_eq!(result, Ok(Some(Value::I32(2144337921 as i32)))); + result.map(|_| ()) +} + +// Line 126 +fn c68_l126_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c68_l126_action_invoke"); + let result = instance.call("f32.load", &[]); + let expected = f32::from_bits(2144337921); + 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 127 +fn c69_l127_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c69_l127_action_invoke"); + let result = instance.call("reset", &[]); + + result.map(|_| ()) +} + +// Line 128 +fn c70_l128_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c70_l128_action_invoke"); + let result = instance.call("i32.load", &[]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 129 +fn c71_l129_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c71_l129_action_invoke"); + let result = instance.call("f32.load", &[]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 130 +fn c72_l130_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c72_l130_action_invoke"); + let result = instance.call("i32.store", &[]); + + result.map(|_| ()) +} + +// Line 131 +fn c73_l131_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c73_l131_action_invoke"); + let result = instance.call("i32.load", &[]); + assert_eq!(result, Ok(Some(Value::I32(2144337921 as i32)))); + result.map(|_| ()) +} + +// Line 132 +fn c74_l132_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c74_l132_action_invoke"); + let result = instance.call("f32.load", &[]); + let expected = f32::from_bits(2144337921); + 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 134 + +#[test] +fn test_module_5() { + let mut instance = create_module_5(); + // We group the calls together + start_module_5(&mut instance); + c61_l119_action_invoke(&mut instance); + c62_l120_action_invoke(&mut instance); + c63_l121_action_invoke(&mut instance); + c64_l122_action_invoke(&mut instance); + c65_l123_action_invoke(&mut instance); + c66_l124_action_invoke(&mut instance); + c67_l125_action_invoke(&mut instance); + c68_l126_action_invoke(&mut instance); + c69_l127_action_invoke(&mut instance); + c70_l128_action_invoke(&mut instance); + c71_l129_action_invoke(&mut instance); + c72_l130_action_invoke(&mut instance); + c73_l131_action_invoke(&mut instance); + c74_l132_action_invoke(&mut instance); +} +fn create_module_6() -> Box { + let module_str = "(module + (type (;0;) (func (result f64))) + (type (;1;) (func (result i64))) + (type (;2;) (func)) + (func (;0;) (type 0) (result f64) + i32.const 0 + f64.load) + (func (;1;) (type 1) (result i64) + i32.const 0 + i64.load) + (func (;2;) (type 2) + i32.const 0 + f64.const nan:0xc000000000001 (;=nan;) + f64.store) + (func (;3;) (type 2) + i32.const 0 + i64.const 9222246136947933185 + i64.store) + (func (;4;) (type 2) + i32.const 0 + i64.const 0 + i64.store) + (memory (;0;) 1 1) + (export \"f64.load\" (func 0)) + (export \"i64.load\" (func 1)) + (export \"f64.store\" (func 2)) + (export \"i64.store\" (func 3)) + (export \"reset\" (func 4)) + (data (;0;) (i32.const 0) \"\\01\\00\\00\\00\\00\\00\\fc\\7f\")) + "; + 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_6(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 144 +fn c76_l144_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c76_l144_action_invoke"); + let result = instance.call("i64.load", &[]); + assert_eq!(result, Ok(Some(Value::I64(9222246136947933185 as i64)))); + result.map(|_| ()) +} + +// Line 145 +fn c77_l145_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c77_l145_action_invoke"); + let result = instance.call("f64.load", &[]); + let expected = f64::from_bits(9222246136947933185); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 146 +fn c78_l146_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c78_l146_action_invoke"); + let result = instance.call("reset", &[]); + + result.map(|_| ()) +} + +// Line 147 +fn c79_l147_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c79_l147_action_invoke"); + let result = instance.call("i64.load", &[]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 148 +fn c80_l148_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c80_l148_action_invoke"); + let result = instance.call("f64.load", &[]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 149 +fn c81_l149_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c81_l149_action_invoke"); + let result = instance.call("f64.store", &[]); + + result.map(|_| ()) +} + +// Line 150 +fn c82_l150_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c82_l150_action_invoke"); + let result = instance.call("i64.load", &[]); + assert_eq!(result, Ok(Some(Value::I64(9222246136947933185 as i64)))); + result.map(|_| ()) +} + +// Line 151 +fn c83_l151_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c83_l151_action_invoke"); + let result = instance.call("f64.load", &[]); + let expected = f64::from_bits(9222246136947933185); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 152 +fn c84_l152_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c84_l152_action_invoke"); + let result = instance.call("reset", &[]); + + result.map(|_| ()) +} + +// Line 153 +fn c85_l153_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c85_l153_action_invoke"); + let result = instance.call("i64.load", &[]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 154 +fn c86_l154_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c86_l154_action_invoke"); + let result = instance.call("f64.load", &[]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 155 +fn c87_l155_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c87_l155_action_invoke"); + let result = instance.call("i64.store", &[]); + + result.map(|_| ()) +} + +// Line 156 +fn c88_l156_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c88_l156_action_invoke"); + let result = instance.call("i64.load", &[]); + assert_eq!(result, Ok(Some(Value::I64(9222246136947933185 as i64)))); + result.map(|_| ()) +} + +// Line 157 +fn c89_l157_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c89_l157_action_invoke"); + let result = instance.call("f64.load", &[]); + let expected = f64::from_bits(9222246136947933185); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +#[test] +fn test_module_6() { + let mut instance = create_module_6(); + // We group the calls together + start_module_6(&mut instance); + c76_l144_action_invoke(&mut instance); + c77_l145_action_invoke(&mut instance); + c78_l146_action_invoke(&mut instance); + c79_l147_action_invoke(&mut instance); + c80_l148_action_invoke(&mut instance); + c81_l149_action_invoke(&mut instance); + c82_l150_action_invoke(&mut instance); + c83_l151_action_invoke(&mut instance); + c84_l152_action_invoke(&mut instance); + c85_l153_action_invoke(&mut instance); + c86_l154_action_invoke(&mut instance); + c87_l155_action_invoke(&mut instance); + c88_l156_action_invoke(&mut instance); + c89_l157_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/float_misc.rs b/lib/runtime/tests/spectests/float_misc.rs new file mode 100644 index 000000000..9021163f0 --- /dev/null +++ b/lib/runtime/tests/spectests/float_misc.rs @@ -0,0 +1,4229 @@ +// 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/float_misc.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 17 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func (param f32 f32) (result f32))) + (type (;1;) (func (param f32) (result f32))) + (type (;2;) (func (param f64 f64) (result f64))) + (type (;3;) (func (param f64) (result f64))) + (func (;0;) (type 0) (param f32 f32) (result f32) + get_local 0 + get_local 1 + f32.add) + (func (;1;) (type 0) (param f32 f32) (result f32) + get_local 0 + get_local 1 + f32.sub) + (func (;2;) (type 0) (param f32 f32) (result f32) + get_local 0 + get_local 1 + f32.mul) + (func (;3;) (type 0) (param f32 f32) (result f32) + get_local 0 + get_local 1 + f32.div) + (func (;4;) (type 1) (param f32) (result f32) + get_local 0 + f32.sqrt) + (func (;5;) (type 1) (param f32) (result f32) + get_local 0 + f32.abs) + (func (;6;) (type 1) (param f32) (result f32) + get_local 0 + f32.neg) + (func (;7;) (type 0) (param f32 f32) (result f32) + get_local 0 + get_local 1 + f32.copysign) + (func (;8;) (type 1) (param f32) (result f32) + get_local 0 + f32.ceil) + (func (;9;) (type 1) (param f32) (result f32) + get_local 0 + f32.floor) + (func (;10;) (type 1) (param f32) (result f32) + get_local 0 + f32.trunc) + (func (;11;) (type 1) (param f32) (result f32) + get_local 0 + f32.nearest) + (func (;12;) (type 0) (param f32 f32) (result f32) + get_local 0 + get_local 1 + f32.min) + (func (;13;) (type 0) (param f32 f32) (result f32) + get_local 0 + get_local 1 + f32.max) + (func (;14;) (type 2) (param f64 f64) (result f64) + get_local 0 + get_local 1 + f64.add) + (func (;15;) (type 2) (param f64 f64) (result f64) + get_local 0 + get_local 1 + f64.sub) + (func (;16;) (type 2) (param f64 f64) (result f64) + get_local 0 + get_local 1 + f64.mul) + (func (;17;) (type 2) (param f64 f64) (result f64) + get_local 0 + get_local 1 + f64.div) + (func (;18;) (type 3) (param f64) (result f64) + get_local 0 + f64.sqrt) + (func (;19;) (type 3) (param f64) (result f64) + get_local 0 + f64.abs) + (func (;20;) (type 3) (param f64) (result f64) + get_local 0 + f64.neg) + (func (;21;) (type 2) (param f64 f64) (result f64) + get_local 0 + get_local 1 + f64.copysign) + (func (;22;) (type 3) (param f64) (result f64) + get_local 0 + f64.ceil) + (func (;23;) (type 3) (param f64) (result f64) + get_local 0 + f64.floor) + (func (;24;) (type 3) (param f64) (result f64) + get_local 0 + f64.trunc) + (func (;25;) (type 3) (param f64) (result f64) + get_local 0 + f64.nearest) + (func (;26;) (type 2) (param f64 f64) (result f64) + get_local 0 + get_local 1 + f64.min) + (func (;27;) (type 2) (param f64 f64) (result f64) + get_local 0 + get_local 1 + f64.max) + (export \"f32.add\" (func 0)) + (export \"f32.sub\" (func 1)) + (export \"f32.mul\" (func 2)) + (export \"f32.div\" (func 3)) + (export \"f32.sqrt\" (func 4)) + (export \"f32.abs\" (func 5)) + (export \"f32.neg\" (func 6)) + (export \"f32.copysign\" (func 7)) + (export \"f32.ceil\" (func 8)) + (export \"f32.floor\" (func 9)) + (export \"f32.trunc\" (func 10)) + (export \"f32.nearest\" (func 11)) + (export \"f32.min\" (func 12)) + (export \"f32.max\" (func 13)) + (export \"f64.add\" (func 14)) + (export \"f64.sub\" (func 15)) + (export \"f64.mul\" (func 16)) + (export \"f64.div\" (func 17)) + (export \"f64.sqrt\" (func 18)) + (export \"f64.abs\" (func 19)) + (export \"f64.neg\" (func 20)) + (export \"f64.copysign\" (func 21)) + (export \"f64.ceil\" (func 22)) + (export \"f64.floor\" (func 23)) + (export \"f64.trunc\" (func 24)) + (export \"f64.nearest\" (func 25)) + (export \"f64.min\" (func 26)) + (export \"f64.max\" (func 27))) + "; + let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); + 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 50 +fn c1_l50_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l50_action_invoke"); + let result = instance.call("f32.add", &[Value::F32((1.1234568f32).to_bits()), Value::F32((0.00000000012345f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.1234568f32).to_bits())))); + result.map(|_| ()) +} + +// Line 51 +fn c2_l51_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l51_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((1.123456789f64).to_bits()), Value::F64((0.00000000012345f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.12345678912345f64).to_bits())))); + result.map(|_| ()) +} + +// Line 55 +fn c3_l55_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l55_action_invoke"); + let result = instance.call("f32.add", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000059604645f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 56 +fn c4_l56_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l56_action_invoke"); + let result = instance.call("f32.add", &[Value::F32((1.0f32).to_bits()), Value::F32((0.00000005960465f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 57 +fn c5_l57_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l57_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((1.0f64).to_bits()), Value::F64((0.00000000000000011102230246251565f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 58 +fn c6_l58_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l58_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((1.0f64).to_bits()), Value::F64((0.00000000000000011102230246251568f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0000000000000002f64).to_bits())))); + result.map(|_| ()) +} + +// Line 61 +fn c7_l61_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l61_action_invoke"); + let result = instance.call("f32.add", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754942f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 62 +fn c8_l62_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l62_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 67 +fn c9_l67_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l67_action_invoke"); + let result = instance.call("f32.add", &[Value::F32((2147483600.0f32).to_bits()), Value::F32((1024.25f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((2147484700.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 68 +fn c10_l68_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c10_l68_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((9223372036854776000.0f64).to_bits()), Value::F64((1024.25f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((9223372036854778000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 72 +fn c11_l72_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c11_l72_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003645561009778199f64).to_bits()), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000292f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000036455610097781983f64).to_bits())))); + result.map(|_| ()) +} + +// Line 75 +fn c12_l75_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c12_l75_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((9007199254740992.0f64).to_bits()), Value::F64((1.00001f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((9007199254740994.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 78 +fn c13_l78_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c13_l78_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((9007199254740994.0f64).to_bits()), Value::F64((0.9999847412109375f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((9007199254740994.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 81 +fn c14_l81_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c14_l81_action_invoke"); + let result = instance.call("f32.add", &[Value::F32((8388608.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((8388608.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 82 +fn c15_l82_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c15_l82_action_invoke"); + let result = instance.call("f32.add", &[Value::F32((8388609.0f32).to_bits()), Value::F32((0.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((8388610.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 83 +fn c16_l83_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c16_l83_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((4503599627370496.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((4503599627370496.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 84 +fn c17_l84_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c17_l84_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((4503599627370497.0f64).to_bits()), Value::F64((0.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((4503599627370498.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 87 +fn c18_l87_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c18_l87_action_invoke"); + let result = instance.call("f32.add", &[Value::F32((-6207600000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000002309799f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-6207600000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 88 +fn c19_l88_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c19_l88_action_invoke"); + let result = instance.call("f32.add", &[Value::F32((209865800000000000000.0f32).to_bits()), Value::F32((-5270152500000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((209860530000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 89 +fn c20_l89_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c20_l89_action_invoke"); + let result = instance.call("f32.add", &[Value::F32((0.0000000000000000000000001963492f32).to_bits()), Value::F32((0.000000000000000000000000000000000000046220067f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000000001963492f32).to_bits())))); + result.map(|_| ()) +} + +// Line 90 +fn c21_l90_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c21_l90_action_invoke"); + let result = instance.call("f32.add", &[Value::F32((640905000000.0f32).to_bits()), Value::F32((-64449550000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-64448910000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 91 +fn c22_l91_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c22_l91_action_invoke"); + let result = instance.call("f32.add", &[Value::F32((0.0000601966f32).to_bits()), Value::F32((120372790000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((120372790000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 92 +fn c23_l92_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c23_l92_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009218993827002741f64).to_bits()), Value::F64((-1283078243878048500000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1283078243878048500000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 93 +fn c24_l93_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c24_l93_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((-96503407870148960000000.0f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000004670208988478548f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-96503407870148960000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 94 +fn c25_l94_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c25_l94_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((0.0000000000000000000000000000000000000000000028559147675434106f64).to_bits()), Value::F64((-0.00026124280570653086f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00026124280570653086f64).to_bits())))); + result.map(|_| ()) +} + +// Line 95 +fn c26_l95_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c26_l95_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((417909928165296700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((79335564741512700000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((417909928165296700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 96 +fn c27_l96_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c27_l96_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((8265442868747023000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((43603327839006250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((43603327839006250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 99 +fn c28_l99_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c28_l99_action_invoke"); + let result = instance.call("f32.add", &[Value::F32((5238404000000000000000.0f32).to_bits()), Value::F32((-1570182.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((5238404000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 100 +fn c29_l100_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c29_l100_action_invoke"); + let result = instance.call("f32.add", &[Value::F32((0.00000000000004258938f32).to_bits()), Value::F32((-0.0000000000000000000000057092353f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.00000000000004258938f32).to_bits())))); + result.map(|_| ()) +} + +// Line 101 +fn c30_l101_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c30_l101_action_invoke"); + let result = instance.call("f32.add", &[Value::F32((-0.00000000000027251026f32).to_bits()), Value::F32((83711560000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((83711560000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 102 +fn c31_l102_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c31_l102_action_invoke"); + let result = instance.call("f32.add", &[Value::F32((-0.0000000000000884536f32).to_bits()), Value::F32((-0.000000000000000000000000000000015165626f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0000000000000884536f32).to_bits())))); + result.map(|_| ()) +} + +// Line 103 +fn c32_l103_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c32_l103_action_invoke"); + let result = instance.call("f32.add", &[Value::F32((0.0010521035f32).to_bits()), Value::F32((-0.000000000000000000000000000000007582135f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0010521035f32).to_bits())))); + result.map(|_| ()) +} + +// Line 104 +fn c33_l104_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c33_l104_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((1511135228188924600000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002760218100603169f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1511135228188924600000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 105 +fn c34_l105_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c34_l105_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((62386719760360280000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.0000000000000000008592185488839212f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((62386719760360280000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 106 +fn c35_l106_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c35_l106_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004195022848436354f64).to_bits()), Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000029225342022551453f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004195022848436354f64).to_bits())))); + result.map(|_| ()) +} + +// Line 107 +fn c36_l107_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c36_l107_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((-215220546714824520000000000000000000000000000.0f64).to_bits()), Value::F64((-1112220412047137200000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-216332767126871650000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 108 +fn c37_l108_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c37_l108_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((-13.6911535055856f64).to_bits()), Value::F64((2066117898924419800000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((2066117898924419800000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 111 +fn c38_l111_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c38_l111_action_invoke"); + let result = instance.call("f32.add", &[Value::F32((-0.000000000000000000000000000000000006456021f32).to_bits()), Value::F32((0.00000000000020219949f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.00000000000020219949f32).to_bits())))); + result.map(|_| ()) +} + +// Line 112 +fn c39_l112_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c39_l112_action_invoke"); + let result = instance.call("f32.add", &[Value::F32((-0.000026823169f32).to_bits()), Value::F32((0.000000011196016f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000026811973f32).to_bits())))); + result.map(|_| ()) +} + +// Line 113 +fn c40_l113_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c40_l113_action_invoke"); + let result = instance.call("f32.add", &[Value::F32((-128526170000.0f32).to_bits()), Value::F32((0.0000000000000000000000000000000027356305f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-128526170000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 114 +fn c41_l114_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c41_l114_action_invoke"); + let result = instance.call("f32.add", &[Value::F32((0.000000000000000000000000000000000004158973f32).to_bits()), Value::F32((-1573528700.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1573528700.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 115 +fn c42_l115_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c42_l115_action_invoke"); + let result = instance.call("f32.add", &[Value::F32((-0.0000000000000000000000000000000000009338769f32).to_bits()), Value::F32((78647514000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((78647514000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 116 +fn c43_l116_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c43_l116_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000021986596650683218f64).to_bits()), Value::F64((-235447594845461340000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-235447594845461340000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 117 +fn c44_l117_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c44_l117_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((-314175619593595700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-30114098514611660000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-314175649707694230000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 118 +fn c45_l118_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c45_l118_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013722858367681836f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000011571842749688977f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000011571842749688977f64).to_bits())))); + result.map(|_| ()) +} + +// Line 119 +fn c46_l119_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c46_l119_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009828583756551075f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016862581574752944f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009828583756551075f64).to_bits())))); + result.map(|_| ()) +} + +// Line 120 +fn c47_l120_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c47_l120_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((-672584203522163500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((8374007930974482000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-672584203522163500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 123 +fn c48_l123_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c48_l123_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((-210896605327889950000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((581483233421196300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((581483022524591100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 124 +fn c49_l124_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c49_l124_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((102315792666821480000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((450204300797494900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((102315792667271680000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 125 +fn c50_l125_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c50_l125_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((-130529978570956560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((154899434220186570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((154899434220186450000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 126 +fn c51_l126_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c51_l126_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((47629997434721684000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((455586451058259700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((455586451058259700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 127 +fn c52_l127_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c52_l127_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003958952516558414f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000023092460710062946f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000230924607140219f64).to_bits())))); + result.map(|_| ()) +} + +// Line 130 +fn c53_l130_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c53_l130_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((-43780558475415996000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-49680759347383435000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-49680759347383435000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 131 +fn c54_l131_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c54_l131_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((21174311168546080000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-26385928474612128000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-26385928474612128000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 132 +fn c55_l132_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c55_l132_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((-9508489561700635000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007858068235728165f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-9508489561700635000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 133 +fn c56_l133_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c56_l133_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005079144928553737f64).to_bits()), Value::F64((-354021720742499800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-354021720742499800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 134 +fn c57_l134_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c57_l134_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000004165382103988111f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010865942283516648f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000004165382103988111f64).to_bits())))); + result.map(|_| ()) +} + +// Line 137 +fn c58_l137_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c58_l137_action_invoke"); + let result = instance.call("f32.add", &[Value::F32((97215650000000000000000000000000000.0f32).to_bits()), Value::F32((305590870000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((305688080000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 138 +fn c59_l138_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c59_l138_action_invoke"); + let result = instance.call("f32.add", &[Value::F32((270465630000000000000000000000000000000.0f32).to_bits()), Value::F32((-230236850000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((270465400000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 139 +fn c60_l139_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c60_l139_action_invoke"); + let result = instance.call("f32.add", &[Value::F32((357209300000000000000000000000000000.0f32).to_bits()), Value::F32((-236494050000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-236136840000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 140 +fn c61_l140_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c61_l140_action_invoke"); + let result = instance.call("f32.add", &[Value::F32((-1484234100000000000000000000000000000.0f32).to_bits()), Value::F32((-328991400000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-330475620000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 141 +fn c62_l141_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c62_l141_action_invoke"); + let result = instance.call("f32.add", &[Value::F32((-219885600000000000000000000000000000000.0f32).to_bits()), Value::F32((-81560930000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-301446520000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 142 +fn c63_l142_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c63_l142_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((90390204939547630000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((22943337422040356000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((90390204939570580000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 143 +fn c64_l143_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c64_l143_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((165916059736246050000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((12577349331444160000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((165916059748823400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 144 +fn c65_l144_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c65_l144_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((-136351292561394300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((60507030603873580000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-136290785530790440000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 145 +fn c66_l145_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c66_l145_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((-34377613258227424000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((169947152758793490000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((169947118381180220000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 146 +fn c67_l146_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c67_l146_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((92273427008645570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-39269416451018680000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((92273426969376150000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 149 +fn c68_l149_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c68_l149_action_invoke"); + let result = instance.call("f32.add", &[Value::F32((0.000000000000000000000000000000000000008313455f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000873f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000008314328f32).to_bits())))); + result.map(|_| ()) +} + +// Line 150 +fn c69_l150_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c69_l150_action_invoke"); + let result = instance.call("f32.add", &[Value::F32((0.000000000000000000000000000000000000000000052f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000003f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000049f32).to_bits())))); + result.map(|_| ()) +} + +// Line 151 +fn c70_l151_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c70_l151_action_invoke"); + let result = instance.call("f32.add", &[Value::F32((-0.000000000000000000000000000000000000000000011f32).to_bits()), Value::F32((0.000000000000000000000000000000000000005186284f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000005186273f32).to_bits())))); + result.map(|_| ()) +} + +// Line 152 +fn c71_l152_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c71_l152_action_invoke"); + let result = instance.call("f32.add", &[Value::F32((-0.000000000000000000000000000000000000000000028f32).to_bits()), Value::F32((0.00000000000000000000000000000000000023675283f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000000000000000000002367528f32).to_bits())))); + result.map(|_| ()) +} + +// Line 153 +fn c72_l153_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c72_l153_action_invoke"); + let result = instance.call("f32.add", &[Value::F32((0.000000000000000000000000000000000000000000635f32).to_bits()), Value::F32((-0.00000000000000000000000000000000000000003327f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000032635f32).to_bits())))); + result.map(|_| ()) +} + +// Line 154 +fn c73_l154_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c73_l154_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000028461489375936755f64).to_bits()), Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005130160608603642f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002284011671009967f64).to_bits())))); + result.map(|_| ()) +} + +// Line 155 +fn c74_l155_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c74_l155_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000047404811354775f64).to_bits()), Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008895417776504167f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004154936641026667f64).to_bits())))); + result.map(|_| ()) +} + +// Line 156 +fn c75_l156_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c75_l156_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009330082001250494f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000029863980609419717f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003919406261067021f64).to_bits())))); + result.map(|_| ()) +} + +// Line 157 +fn c76_l157_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c76_l157_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014418693884494008f64).to_bits()), Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016324914377759187f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001906220493265178f64).to_bits())))); + result.map(|_| ()) +} + +// Line 158 +fn c77_l158_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c77_l158_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000043203619362281506f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002521511966399844f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017988499698283067f64).to_bits())))); + result.map(|_| ()) +} + +// Line 162 +fn c78_l162_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c78_l162_action_invoke"); + let result = instance.call("f32.add", &[Value::F32((340282330000000000000000000000000000000.0f32).to_bits()), Value::F32((20282410000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 163 +fn c79_l163_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c79_l163_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((179769313486231550000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((19958403095347200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 166 +fn c80_l166_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c80_l166_action_invoke"); + let result = instance.call("f32.add", &[Value::F32((2.0f32).to_bits()), Value::F32((2.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((4.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 167 +fn c81_l167_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c81_l167_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((2.0f64).to_bits()), Value::F64((2.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((4.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 170 +fn c82_l170_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c82_l170_action_invoke"); + let result = instance.call("f32.add", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((10141204000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 171 +fn c83_l171_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c83_l171_action_invoke"); + let result = instance.call("f32.add", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((10141205000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 172 +fn c84_l172_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c84_l172_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((9979201547673598000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 173 +fn c85_l173_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c85_l173_action_invoke"); + let result = instance.call("f64.add", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((9979201547673600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 177 +fn c86_l177_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c86_l177_action_invoke"); + let result = instance.call("f32.sub", &[Value::F32((65536.0f32).to_bits()), Value::F32((0.000000000007275958f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((65536.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 178 +fn c87_l178_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c87_l178_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((65536.0f64).to_bits()), Value::F64((0.000000000007275957614183426f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((65535.99999999999f64).to_bits())))); + result.map(|_| ()) +} + +// Line 182 +fn c88_l182_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c88_l182_action_invoke"); + let result = instance.call("f32.sub", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000029802322f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 183 +fn c89_l183_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c89_l183_action_invoke"); + let result = instance.call("f32.sub", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000029802326f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.99999994f32).to_bits())))); + result.map(|_| ()) +} + +// Line 184 +fn c90_l184_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c90_l184_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((1.0f64).to_bits()), Value::F64((0.00000000000000005551115123125783f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 185 +fn c91_l185_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c91_l185_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((1.0f64).to_bits()), Value::F64((0.00000000000000005551115123125784f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.9999999999999999f64).to_bits())))); + result.map(|_| ()) +} + +// Line 188 +fn c92_l188_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c92_l188_action_invoke"); + let result = instance.call("f32.sub", &[Value::F32((0.00000000000000000000000000000002379208f32).to_bits()), Value::F32((-722129800000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((722129800000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 189 +fn c93_l189_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c93_l189_action_invoke"); + let result = instance.call("f32.sub", &[Value::F32((-842284000000000000000000000000000000.0f32).to_bits()), Value::F32((-11118414000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-842284000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 190 +fn c94_l190_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c94_l190_action_invoke"); + let result = instance.call("f32.sub", &[Value::F32((1.4549444f32).to_bits()), Value::F32((-0.00000000000000000000000033792615f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.4549444f32).to_bits())))); + result.map(|_| ()) +} + +// Line 191 +fn c95_l191_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c95_l191_action_invoke"); + let result = instance.call("f32.sub", &[Value::F32((0.0000000000000000000000000000000000094808914f32).to_bits()), Value::F32((0.000000000000000000000018589502f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000018589502f32).to_bits())))); + result.map(|_| ()) +} + +// Line 192 +fn c96_l192_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c96_l192_action_invoke"); + let result = instance.call("f32.sub", &[Value::F32((0.000006181167f32).to_bits()), Value::F32((-0.0000000000000000000000000000000093959864f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000006181167f32).to_bits())))); + result.map(|_| ()) +} + +// Line 193 +fn c97_l193_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c97_l193_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000775701650124413f64).to_bits()), Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002524845082116609f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000775701650124413f64).to_bits())))); + result.map(|_| ()) +} + +// Line 194 +fn c98_l194_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c98_l194_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((-20991871064832710000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.0000000000000000000000000000000000000000000000038165079778426864f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-20991871064832710000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 195 +fn c99_l195_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c99_l195_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000028592030964162332f64).to_bits()), Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020889465194336087f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000028592030964162332f64).to_bits())))); + result.map(|_| ()) +} + +// Line 196 +fn c100_l196_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c100_l196_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000303879528930943f64).to_bits()), Value::F64((-23204941114021897000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((23204941114021897000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 197 +fn c101_l197_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c101_l197_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((-0.00000000000000000000000000000000000000000014953904039036317f64).to_bits()), Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010592252695645683f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000014953904039036317f64).to_bits())))); + result.map(|_| ()) +} + +// Line 200 +fn c102_l200_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c102_l200_action_invoke"); + let result = instance.call("f32.sub", &[Value::F32((-448601660000000000000000000000000.0f32).to_bits()), Value::F32((-8984148000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((8535546400000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 201 +fn c103_l201_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c103_l201_action_invoke"); + let result = instance.call("f32.sub", &[Value::F32((-899427400000000000000000000000000.0f32).to_bits()), Value::F32((91.579384f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-899427400000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 202 +fn c104_l202_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c104_l202_action_invoke"); + let result = instance.call("f32.sub", &[Value::F32((-0.00000000000000000000000011975f32).to_bits()), Value::F32((0.000000063140405f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000063140405f32).to_bits())))); + result.map(|_| ()) +} + +// Line 203 +fn c105_l203_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c105_l203_action_invoke"); + let result = instance.call("f32.sub", &[Value::F32((-0.000000000000000000000011800487f32).to_bits()), Value::F32((-0.00031558736f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.00031558736f32).to_bits())))); + result.map(|_| ()) +} + +// Line 204 +fn c106_l204_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c106_l204_action_invoke"); + let result = instance.call("f32.sub", &[Value::F32((-736483800000000000000000000000.0f32).to_bits()), Value::F32((0.0000000000000000030824513f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-736483800000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 205 +fn c107_l205_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c107_l205_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((-9410469964196796000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-17306275691385970000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((17306275691385970000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 206 +fn c108_l206_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c108_l206_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002877908564233173f64).to_bits()), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002339448785991429f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002877908564233173f64).to_bits())))); + result.map(|_| ()) +} + +// Line 207 +fn c109_l207_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c109_l207_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((-0.0000000000000000000000000000000000000000000000000000000000009719219783531962f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001572015082308034f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000000000000000000000000000000000000000000000009719219783531962f64).to_bits())))); + result.map(|_| ()) +} + +// Line 208 +fn c110_l208_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c110_l208_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000034908896031751274f64).to_bits()), Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000019928479721303208f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000019928479721303208f64).to_bits())))); + result.map(|_| ()) +} + +// Line 209 +fn c111_l209_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c111_l209_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((-7538298763725556000000000000000000.0f64).to_bits()), Value::F64((4447012580193329000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-4447012580193329000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 212 +fn c112_l212_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c112_l212_action_invoke"); + let result = instance.call("f32.sub", &[Value::F32((75846976000000000000000000000.0f32).to_bits()), Value::F32((0.000046391753f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((75846976000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 213 +fn c113_l213_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c113_l213_action_invoke"); + let result = instance.call("f32.sub", &[Value::F32((-567139.9f32).to_bits()), Value::F32((-0.000000000030334842f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-567139.9f32).to_bits())))); + result.map(|_| ()) +} + +// Line 214 +fn c114_l214_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c114_l214_action_invoke"); + let result = instance.call("f32.sub", &[Value::F32((-0.000000000017412261f32).to_bits()), Value::F32((-0.000000000000000017877793f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000017412244f32).to_bits())))); + result.map(|_| ()) +} + +// Line 215 +fn c115_l215_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c115_l215_action_invoke"); + let result = instance.call("f32.sub", &[Value::F32((-0.000065645545f32).to_bits()), Value::F32((0.00014473806f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.00021038362f32).to_bits())))); + result.map(|_| ()) +} + +// Line 216 +fn c116_l216_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c116_l216_action_invoke"); + let result = instance.call("f32.sub", &[Value::F32((-0.00000000016016115f32).to_bits()), Value::F32((-0.000000000000000000000000000000085380075f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.00000000016016115f32).to_bits())))); + result.map(|_| ()) +} + +// Line 217 +fn c117_l217_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c117_l217_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((-0.000000000000000000000000000000000000000000000009358725267183177f64).to_bits()), Value::F64((-31137147338685164000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((31137147338685164000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 218 +fn c118_l218_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c118_l218_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((-4390767596767215000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-67890457158958560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((67890457158958560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 219 +fn c119_l219_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c119_l219_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000036288281010831153f64).to_bits()), Value::F64((3383199683245004400000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-3383199683245004400000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 220 +fn c120_l220_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c120_l220_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003645097751812619f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000031423490969686624f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000031423491006137603f64).to_bits())))); + result.map(|_| ()) +} + +// Line 221 +fn c121_l221_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c121_l221_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008021529638989887f64).to_bits()), Value::F64((-0.00006774972769072139f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00006774972769072139f64).to_bits())))); + result.map(|_| ()) +} + +// Line 224 +fn c122_l224_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c122_l224_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((0.000000000000000000000005816988065793039f64).to_bits()), Value::F64((0.000000000000000000000000000000000025021499241540866f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000005816988065768018f64).to_bits())))); + result.map(|_| ()) +} + +// Line 225 +fn c123_l225_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c123_l225_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000043336683304809554f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016945582607476316f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000043336683135353726f64).to_bits())))); + result.map(|_| ()) +} + +// Line 226 +fn c124_l226_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c124_l226_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000006908052676315257f64).to_bits()), Value::F64((0.0000000000000000000000000000000000000000000000000000000000012001773734799856f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000000000000000000000000000000000000000000000012001773734799856f64).to_bits())))); + result.map(|_| ()) +} + +// Line 227 +fn c125_l227_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c125_l227_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((-0.0000000000022044291547443813f64).to_bits()), Value::F64((-0.0000000000000000000027947429925618632f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000002204429151949638f64).to_bits())))); + result.map(|_| ()) +} + +// Line 228 +fn c126_l228_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c126_l228_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((0.00000004016393569117761f64).to_bits()), Value::F64((0.17053881989395447f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.17053877973001877f64).to_bits())))); + result.map(|_| ()) +} + +// Line 231 +fn c127_l231_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c127_l231_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010015106898667285f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004785375958943186f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000047853759589431757f64).to_bits())))); + result.map(|_| ()) +} + +// Line 232 +fn c128_l232_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c128_l232_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((-15618959953.641388f64).to_bits()), Value::F64((598234410620718900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-598234410620718900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 233 +fn c129_l233_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c129_l233_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((38832071540376680000000000000000000.0f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000042192279274320304f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((38832071540376680000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 234 +fn c130_l234_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c130_l234_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010705986890807897f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017466607734737216f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010705986890807897f64).to_bits())))); + result.map(|_| ()) +} + +// Line 235 +fn c131_l235_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c131_l235_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((0.00000000000000000949378346261834f64).to_bits()), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014584885434950294f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000949378346261834f64).to_bits())))); + result.map(|_| ()) +} + +// Line 239 +fn c132_l239_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c132_l239_action_invoke"); + let result = instance.call("f32.sub", &[Value::F32((23.140692f32).to_bits()), Value::F32((3.1415927f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((19.9991f32).to_bits())))); + result.map(|_| ()) +} + +// Line 240 +fn c133_l240_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c133_l240_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((23.14069263277927f64).to_bits()), Value::F64((3.141592653589793f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((19.999099979189477f64).to_bits())))); + result.map(|_| ()) +} + +// Line 243 +fn c134_l243_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c134_l243_action_invoke"); + let result = instance.call("f32.sub", &[Value::F32((2999999.0f32).to_bits()), Value::F32((2999998.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 244 +fn c135_l244_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c135_l244_action_invoke"); + let result = instance.call("f32.sub", &[Value::F32((1999999.0f32).to_bits()), Value::F32((1999995.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((4.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 245 +fn c136_l245_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c136_l245_action_invoke"); + let result = instance.call("f32.sub", &[Value::F32((1999999.0f32).to_bits()), Value::F32((1999993.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((6.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 246 +fn c137_l246_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c137_l246_action_invoke"); + let result = instance.call("f32.sub", &[Value::F32((400002.0f32).to_bits()), Value::F32((400001.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 247 +fn c138_l247_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c138_l247_action_invoke"); + let result = instance.call("f32.sub", &[Value::F32((400002.0f32).to_bits()), Value::F32((400000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((2.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 248 +fn c139_l248_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c139_l248_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((2999999999999999.0f64).to_bits()), Value::F64((2999999999999998.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 249 +fn c140_l249_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c140_l249_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((1999999999999999.0f64).to_bits()), Value::F64((1999999999999995.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((4.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 250 +fn c141_l250_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c141_l250_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((1999999999999999.0f64).to_bits()), Value::F64((1999999999999993.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 251 +fn c142_l251_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c142_l251_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((400000000000002.0f64).to_bits()), Value::F64((400000000000001.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 252 +fn c143_l252_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c143_l252_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((400000000000002.0f64).to_bits()), Value::F64((400000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((2.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 255 +fn c144_l255_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c144_l255_action_invoke"); + let result = instance.call("f32.sub", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754942f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 256 +fn c145_l256_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c145_l256_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 259 +fn c146_l259_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c146_l259_action_invoke"); + let result = instance.call("f32.sub", &[Value::F32((1.0000001f32).to_bits()), Value::F32((0.99999994f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.00000017881393f32).to_bits())))); + result.map(|_| ()) +} + +// Line 260 +fn c147_l260_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c147_l260_action_invoke"); + let result = instance.call("f32.sub", &[Value::F32((1.0000001f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.00000011920929f32).to_bits())))); + result.map(|_| ()) +} + +// Line 261 +fn c148_l261_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c148_l261_action_invoke"); + let result = instance.call("f32.sub", &[Value::F32((1.0f32).to_bits()), Value::F32((0.99999994f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000059604645f32).to_bits())))); + result.map(|_| ()) +} + +// Line 262 +fn c149_l262_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c149_l262_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((1.0000000000000002f64).to_bits()), Value::F64((0.9999999999999999f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000033306690738754696f64).to_bits())))); + result.map(|_| ()) +} + +// Line 263 +fn c150_l263_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c150_l263_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((1.0000000000000002f64).to_bits()), Value::F64((1.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0000000000000002220446049250313f64).to_bits())))); + result.map(|_| ()) +} + +// Line 264 +fn c151_l264_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c151_l264_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((1.0f64).to_bits()), Value::F64((0.9999999999999999f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000011102230246251565f64).to_bits())))); + result.map(|_| ()) +} + +// Line 268 +fn c152_l268_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c152_l268_action_invoke"); + let result = instance.call("f32.sub", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((10141204000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 269 +fn c153_l269_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c153_l269_action_invoke"); + let result = instance.call("f32.sub", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((10141205000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282330000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 270 +fn c154_l270_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c154_l270_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((9979201547673598000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 271 +fn c155_l271_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c155_l271_action_invoke"); + let result = instance.call("f64.sub", &[Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((9979201547673600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231550000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 274 +fn c156_l274_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c156_l274_action_invoke"); + let result = instance.call("f32.mul", &[Value::F32((1000000000000000.0f32).to_bits()), Value::F32((1000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((999999940000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 275 +fn c157_l275_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c157_l275_action_invoke"); + let result = instance.call("f32.mul", &[Value::F32((100000000000000000000.0f32).to_bits()), Value::F32((100000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 276 +fn c158_l276_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c158_l276_action_invoke"); + let result = instance.call("f32.mul", &[Value::F32((10000000000000000000000000.0f32).to_bits()), Value::F32((10000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 277 +fn c159_l277_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c159_l277_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((1000000000000000.0f64).to_bits()), Value::F64((1000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 278 +fn c160_l278_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c160_l278_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((100000000000000000000.0f64).to_bits()), Value::F64((100000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((10000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 279 +fn c161_l279_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c161_l279_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((10000000000000000000000000.0f64).to_bits()), Value::F64((10000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((100000000000000030000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 284 +fn c162_l284_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c162_l284_action_invoke"); + let result = instance.call("f32.mul", &[Value::F32((1848874900.0f32).to_bits()), Value::F32((19954563000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((36893493000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 285 +fn c163_l285_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c163_l285_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((1848874847.0f64).to_bits()), Value::F64((19954562207.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((36893488147419110000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 289 +fn c164_l289_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c164_l289_action_invoke"); + let result = instance.call("f32.mul", &[Value::F32((77.1f32).to_bits()), Value::F32((850.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((65535.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 290 +fn c165_l290_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c165_l290_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((77.1f64).to_bits()), Value::F64((850.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((65534.99999999999f64).to_bits())))); + result.map(|_| ()) +} + +// Line 293 +fn c166_l293_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c166_l293_action_invoke"); + let result = instance.call("f32.mul", &[Value::F32((-2493839400000000000.0f32).to_bits()), Value::F32((0.000000000021176054f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-52809680.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 294 +fn c167_l294_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c167_l294_action_invoke"); + let result = instance.call("f32.mul", &[Value::F32((-6777248400000000000000000000000.0f32).to_bits()), Value::F32((-0.00000000000000000000000000000034758242f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((2.3556523f32).to_bits())))); + result.map(|_| ()) +} + +// Line 295 +fn c168_l295_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c168_l295_action_invoke"); + let result = instance.call("f32.mul", &[Value::F32((-8384397600000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000011948991f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.10018509f32).to_bits())))); + result.map(|_| ()) +} + +// Line 296 +fn c169_l296_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c169_l296_action_invoke"); + let result = instance.call("f32.mul", &[Value::F32((-656765400000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000046889766f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((30.795576f32).to_bits())))); + result.map(|_| ()) +} + +// Line 297 +fn c170_l297_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c170_l297_action_invoke"); + let result = instance.call("f32.mul", &[Value::F32((13328204000000000.0f32).to_bits()), Value::F32((45.567223f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((607329200000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 298 +fn c171_l298_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c171_l298_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((-99426226093342430000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((583177241514245140000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 299 +fn c172_l299_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c172_l299_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002748155824301909f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000002093035437779455f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 300 +fn c173_l300_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c173_l300_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((464888257371302500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-159272886487254360000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-74044094645556960000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 301 +fn c174_l301_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c174_l301_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008261927764172427f64).to_bits()), Value::F64((36684744190529535000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-3030867065492991300000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 302 +fn c175_l302_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c175_l302_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((253838958331769250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007842892881810105f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000019908317594263248f64).to_bits())))); + result.map(|_| ()) +} + +// Line 305 +fn c176_l305_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c176_l305_action_invoke"); + let result = instance.call("f32.mul", &[Value::F32((-0.0000000000000000000000000020153333f32).to_bits()), Value::F32((-5031353000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((10.139854f32).to_bits())))); + result.map(|_| ()) +} + +// Line 306 +fn c177_l306_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c177_l306_action_invoke"); + let result = instance.call("f32.mul", &[Value::F32((12286325000000000000000.0f32).to_bits()), Value::F32((749601.8f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((9209852000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 307 +fn c178_l307_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c178_l307_action_invoke"); + let result = instance.call("f32.mul", &[Value::F32((-0.0000000002763514f32).to_bits()), Value::F32((-35524714000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((9817304000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 308 +fn c179_l308_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c179_l308_action_invoke"); + let result = instance.call("f32.mul", &[Value::F32((218931220000000000000.0f32).to_bits()), Value::F32((-40298.785f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-8822662000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 309 +fn c180_l309_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c180_l309_action_invoke"); + let result = instance.call("f32.mul", &[Value::F32((1691996300.0f32).to_bits()), Value::F32((-122103350000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-206598410000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 310 +fn c181_l310_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c181_l310_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007576316076452304f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004601355879514986f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003486132652344772f64).to_bits())))); + result.map(|_| ()) +} + +// Line 311 +fn c182_l311_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c182_l311_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000012228616081443885f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008055526185180067f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009850793705258527f64).to_bits())))); + result.map(|_| ()) +} + +// Line 312 +fn c183_l312_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c183_l312_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((-2068651246039250800000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-366801071583254800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 313 +fn c184_l313_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c184_l313_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((1543238835610281000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007370621385787007f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1137462916512617700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 314 +fn c185_l314_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c185_l314_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((2235876566242058700000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-760669005920257000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1700762005003744000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 317 +fn c186_l317_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c186_l317_action_invoke"); + let result = instance.call("f32.mul", &[Value::F32((-110087030000000.0f32).to_bits()), Value::F32((-54038020000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 318 +fn c187_l318_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c187_l318_action_invoke"); + let result = instance.call("f32.mul", &[Value::F32((-0.19366351f32).to_bits()), Value::F32((0.0000000000000000000000000000029748954f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0000000000000000000000000000005761287f32).to_bits())))); + result.map(|_| ()) +} + +// Line 319 +fn c188_l319_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c188_l319_action_invoke"); + let result = instance.call("f32.mul", &[Value::F32((-0.0000034300713f32).to_bits()), Value::F32((77991523000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-267516490000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 320 +fn c189_l320_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c189_l320_action_invoke"); + let result = instance.call("f32.mul", &[Value::F32((-99003850000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000020933774f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0000000000020725242f32).to_bits())))); + result.map(|_| ()) +} + +// Line 321 +fn c190_l321_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c190_l321_action_invoke"); + let result = instance.call("f32.mul", &[Value::F32((-129919.07f32).to_bits()), Value::F32((0.0000000000000000000000000000000000018480999f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000000000000000024010342f32).to_bits())))); + result.map(|_| ()) +} + +// Line 322 +fn c191_l322_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c191_l322_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006625572200844895f64).to_bits()), Value::F64((-37374020681740010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000024762427246273877f64).to_bits())))); + result.map(|_| ()) +} + +// Line 323 +fn c192_l323_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c192_l323_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((821076848561758000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012976552328552289f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000010654746691124455f64).to_bits())))); + result.map(|_| ()) +} + +// Line 324 +fn c193_l324_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c193_l324_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((-10223449294906041000000000000000000000000000000000000.0f64).to_bits()), Value::F64((1970855583334680500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-20148942123804574000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 325 +fn c194_l325_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c194_l325_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((2918243080119086000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-63633170941689700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::NEG_INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 326 +fn c195_l326_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c195_l326_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((3407037798802672000000000.0f64).to_bits()), Value::F64((1225791423971563000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((4176317714919266400000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 329 +fn c196_l329_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c196_l329_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044091927284399547f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011518840702296592f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005078878866462432f64).to_bits())))); + result.map(|_| ()) +} + +// Line 330 +fn c197_l330_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c197_l330_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((-0.002980041826472432f64).to_bits()), Value::F64((63125412993218000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-188116371033135940000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 331 +fn c198_l331_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c198_l331_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((-308344578081300100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010081049555008529f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000031084369716557833f64).to_bits())))); + result.map(|_| ()) +} + +// Line 332 +fn c199_l332_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c199_l332_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((349387501315677300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((2131316915930809900.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((744655491768901000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 333 +fn c200_l333_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c200_l333_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000012500108005100234f64).to_bits()), Value::F64((1035265704160467500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-12940933115981990000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 336 +fn c201_l336_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c201_l336_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008947461661755698f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020853844141312436f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000018658897095462173f64).to_bits())))); + result.map(|_| ()) +} + +// Line 337 +fn c202_l337_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c202_l337_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((-0.00000000000000001161813037330394f64).to_bits()), Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000018737038135583668f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000021768935186877886f64).to_bits())))); + result.map(|_| ()) +} + +// Line 338 +fn c203_l338_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c203_l338_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000021752326768352433f64).to_bits()), Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006631210068072052f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014424424827029184f64).to_bits())))); + result.map(|_| ()) +} + +// Line 339 +fn c204_l339_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c204_l339_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007149518157441743f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000022770445062365393f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001627977104264113f64).to_bits())))); + result.map(|_| ()) +} + +// Line 340 +fn c205_l340_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c205_l340_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004817739302150786f64).to_bits()), Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000025375023049719763f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012225024583961697f64).to_bits())))); + result.map(|_| ()) +} + +// Line 343 +fn c206_l343_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c206_l343_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((46576441629501554000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007021344893525714f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000003270292605938992f64).to_bits())))); + result.map(|_| ()) +} + +// Line 344 +fn c207_l344_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c207_l344_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((0.012451716278313712f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000001945309177849331f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000002422243795617958f64).to_bits())))); + result.map(|_| ()) +} + +// Line 345 +fn c208_l345_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c208_l345_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((-3.8312314777598586f64).to_bits()), Value::F64((0.0000000000009039887741742674f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0000000000034633902471580017f64).to_bits())))); + result.map(|_| ()) +} + +// Line 346 +fn c209_l346_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c209_l346_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009843582638849689f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000003375405654777583f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000033226084502443684f64).to_bits())))); + result.map(|_| ()) +} + +// Line 347 +fn c210_l347_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c210_l347_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((-260544537094514460000000.0f64).to_bits()), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000032887528185809035f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000008568665807354412f64).to_bits())))); + result.map(|_| ()) +} + +// Line 350 +fn c211_l350_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c211_l350_action_invoke"); + let result = instance.call("f32.mul", &[Value::F32((0.00000000000000000000002646978f32).to_bits()), Value::F32((0.00000000000000000000002646978f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 351 +fn c212_l351_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c212_l351_action_invoke"); + let result = instance.call("f32.mul", &[Value::F32((0.000000000000000000000026469783f32).to_bits()), Value::F32((0.000000000000000000000026469783f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 352 +fn c213_l352_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c213_l352_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015717277847026285f64).to_bits()), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015717277847026285f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 353 +fn c214_l353_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c214_l353_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015717277847026288f64).to_bits()), Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015717277847026288f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 356 +fn c215_l356_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c215_l356_action_invoke"); + let result = instance.call("f32.mul", &[Value::F32((18446743000000000000.0f32).to_bits()), Value::F32((18446743000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282330000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 357 +fn c216_l357_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c216_l357_action_invoke"); + let result = instance.call("f32.mul", &[Value::F32((18446744000000000000.0f32).to_bits()), Value::F32((18446744000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 358 +fn c217_l358_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c217_l358_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((13407807929942596000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((13407807929942596000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231550000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 359 +fn c218_l359_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c218_l359_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((13407807929942597000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((13407807929942597000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 362 +fn c219_l362_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c219_l362_action_invoke"); + let result = instance.call("f32.mul", &[Value::F32((1.0000001f32).to_bits()), Value::F32((1.0000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0000002f32).to_bits())))); + result.map(|_| ()) +} + +// Line 363 +fn c220_l363_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c220_l363_action_invoke"); + let result = instance.call("f32.mul", &[Value::F32((0.99999994f32).to_bits()), Value::F32((0.99999994f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.9999999f32).to_bits())))); + result.map(|_| ()) +} + +// Line 364 +fn c221_l364_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c221_l364_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((1.0000000000000002f64).to_bits()), Value::F64((1.0000000000000002f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0000000000000004f64).to_bits())))); + result.map(|_| ()) +} + +// Line 365 +fn c222_l365_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c222_l365_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((0.9999999999999999f64).to_bits()), Value::F64((0.9999999999999999f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.9999999999999998f64).to_bits())))); + result.map(|_| ()) +} + +// Line 368 +fn c223_l368_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c223_l368_action_invoke"); + let result = instance.call("f32.mul", &[Value::F32((1.0000001f32).to_bits()), Value::F32((0.99999994f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 369 +fn c224_l369_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c224_l369_action_invoke"); + let result = instance.call("f32.mul", &[Value::F32((1.0000002f32).to_bits()), Value::F32((0.9999999f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 370 +fn c225_l370_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c225_l370_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((1.0000000000000002f64).to_bits()), Value::F64((0.9999999999999999f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 371 +fn c226_l371_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c226_l371_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((1.0000000000000004f64).to_bits()), Value::F64((0.9999999999999998f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0000000000000002f64).to_bits())))); + result.map(|_| ()) +} + +// Line 375 +fn c227_l375_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c227_l375_action_invoke"); + let result = instance.call("f32.mul", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.00000011920929f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 376 +fn c228_l376_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c228_l376_action_invoke"); + let result = instance.call("f64.mul", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.0000000000000002220446049250313f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 379 +fn c229_l379_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c229_l379_action_invoke"); + let result = instance.call("f32.mul", &[Value::F32((-16.001465f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000298465f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000004775883f32).to_bits())))); + result.map(|_| ()) +} + +// Line 382 +fn c230_l382_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c230_l382_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((1.1234568f32).to_bits()), Value::F32((100.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.011234568f32).to_bits())))); + result.map(|_| ()) +} + +// Line 383 +fn c231_l383_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c231_l383_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((8391667.0f32).to_bits()), Value::F32((12582905.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.6669102f32).to_bits())))); + result.map(|_| ()) +} + +// Line 384 +fn c232_l384_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c232_l384_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((65536.0f32).to_bits()), Value::F32((0.000000000007275958f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((9007199000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 385 +fn c233_l385_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c233_l385_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((1.8622957f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000005472795f32).to_bits())))); + result.map(|_| ()) +} + +// Line 386 +fn c234_l386_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c234_l386_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((4.0f32).to_bits()), Value::F32((3.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.3333334f32).to_bits())))); + result.map(|_| ()) +} + +// Line 387 +fn c235_l387_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c235_l387_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((1.123456789f64).to_bits()), Value::F64((100.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.01123456789f64).to_bits())))); + result.map(|_| ()) +} + +// Line 388 +fn c236_l388_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c236_l388_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((8391667.0f64).to_bits()), Value::F64((12582905.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.6669101451532854f64).to_bits())))); + result.map(|_| ()) +} + +// Line 389 +fn c237_l389_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c237_l389_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((65536.0f64).to_bits()), Value::F64((0.000000000007275957614183426f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((9007199254740992.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 390 +fn c238_l390_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c238_l390_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((1.8622957468032837f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001035936395755283f64).to_bits())))); + result.map(|_| ()) +} + +// Line 391 +fn c239_l391_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c239_l391_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((4.0f64).to_bits()), Value::F64((3.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.3333333333333333f64).to_bits())))); + result.map(|_| ()) +} + +// Line 395 +fn c240_l395_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c240_l395_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((4195835.0f32).to_bits()), Value::F32((3145727.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.3338205f32).to_bits())))); + result.map(|_| ()) +} + +// Line 396 +fn c241_l396_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c241_l396_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((4195835.0f64).to_bits()), Value::F64((3145727.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.333820449136241f64).to_bits())))); + result.map(|_| ()) +} + +// Line 399 +fn c242_l399_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c242_l399_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((0.000000000000005029633f32).to_bits()), Value::F32((336324380000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 400 +fn c243_l400_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c243_l400_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((0.000000000000000000000000008921987f32).to_bits()), Value::F32((354097530000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 401 +fn c244_l401_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c244_l401_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((-104167.47f32).to_bits()), Value::F32((0.0000000000000000000000015866623f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-65651950000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 402 +fn c245_l402_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c245_l402_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((-0.000000000000000000000024938657f32).to_bits()), Value::F32((-0.00000000000000000000000000000000000036230088f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((68834107000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 403 +fn c246_l403_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c246_l403_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((-4142204200000.0f32).to_bits()), Value::F32((0.0000000000000000000000011954948f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-3464845000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 404 +fn c247_l404_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c247_l404_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((193901163824483840000000000000000000000000000.0f64).to_bits()), Value::F64((25290742357348314000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000007666883046955921f64).to_bits())))); + result.map(|_| ()) +} + +// Line 405 +fn c248_l405_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c248_l405_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006600332149752304f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003007915153468629f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((219432125342399270000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 406 +fn c249_l406_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c249_l406_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((-934827517366190300000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((4809309529035847000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000019437873809582001f64).to_bits())))); + result.map(|_| ()) +} + +// Line 407 +fn c250_l407_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c250_l407_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((-17598339088417535000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((199386072580682850000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-88262629684409150000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 408 +fn c251_l408_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c251_l408_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((-4566268877844991000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((31282495822334530000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-145968816036246260000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 411 +fn c252_l411_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c252_l411_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((-1039406400000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000012965966f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 412 +fn c253_l412_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c253_l412_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((0.000000000000026831563f32).to_bits()), Value::F32((31241038000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000000000008588563f32).to_bits())))); + result.map(|_| ()) +} + +// Line 413 +fn c254_l413_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c254_l413_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((1.2734247f32).to_bits()), Value::F32((-692783700000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.0000000000000000000000000018381274f32).to_bits())))); + result.map(|_| ()) +} + +// Line 414 +fn c255_l414_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c255_l414_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((0.00000000000000068988827f32).to_bits()), Value::F32((0.000000000000000000000000000000000000003762676f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((183350460000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 415 +fn c256_l415_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c256_l415_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((1819916200000000000000000000.0f32).to_bits()), Value::F32((205067030000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((8.874739f32).to_bits())))); + result.map(|_| ()) +} + +// Line 416 +fn c257_l416_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c257_l416_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000021137715924428077f64).to_bits()), Value::F64((-16733261612910253000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 417 +fn c258_l417_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c258_l417_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008116644948016275f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006517571349002277f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012453480772801648f64).to_bits())))); + result.map(|_| ()) +} + +// Line 418 +fn c259_l418_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c259_l418_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009335476912259029f64).to_bits()), Value::F64((-39099281466396.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000023876338802497726f64).to_bits())))); + result.map(|_| ()) +} + +// Line 419 +fn c260_l419_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c260_l419_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((-1686856985488590200000000.0f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013535993861076857f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-12462010568276012000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 420 +fn c261_l420_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c261_l420_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((-173388773324941200000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-70026160475217470.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((2476057121342590000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 423 +fn c262_l423_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c262_l423_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((93506190.0f32).to_bits()), Value::F32((0.0000000000000000000000000000000000028760885f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 424 +fn c263_l424_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c263_l424_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((-200575400000000000000000.0f32).to_bits()), Value::F32((246697220.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-813042800000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 425 +fn c264_l425_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c264_l425_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((384712200000.0f32).to_bits()), Value::F32((-107037850000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.00000000000000000359417f32).to_bits())))); + result.map(|_| ()) +} + +// Line 426 +fn c265_l426_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c265_l426_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((-4156665000000000000000000000000000.0f32).to_bits()), Value::F32((-901.4192f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((4611245300000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 427 +fn c266_l427_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c266_l427_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((-6702387000000000000000000000.0f32).to_bits()), Value::F32((-14000.255f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((478733200000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 428 +fn c267_l428_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c267_l428_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010085269598907525f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000018780374032850215f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-53701111496.85621f64).to_bits())))); + result.map(|_| ()) +} + +// Line 429 +fn c268_l429_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c268_l429_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((-32571664562951100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005885738519211168f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 430 +fn c269_l430_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c269_l430_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000031640946861233317f64).to_bits()), Value::F64((0.000000000000000000045854510556516254f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006900291046010721f64).to_bits())))); + result.map(|_| ()) +} + +// Line 431 +fn c270_l431_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c270_l431_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((-526842242946656600000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014816907071451201f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((355568298030134360000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 432 +fn c271_l432_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c271_l432_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((4039956270017490000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-47097881971884274000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0000000000857778757955442f64).to_bits())))); + result.map(|_| ()) +} + +// Line 435 +fn c272_l435_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c272_l435_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((-203959560468347600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-74740887394612260000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((2728888665604071000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 436 +fn c273_l436_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c273_l436_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((-304261712294687660000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-2655679232658824300000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((114570204320220420000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 437 +fn c274_l437_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c274_l437_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((49235240512480730000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((-366340828310036700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013439736089369927f64).to_bits())))); + result.map(|_| ()) +} + +// Line 438 +fn c275_l438_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c275_l438_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((289260843556341600000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((517194875837335500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0000000000000000000000000000000000000000000000000000000000000005592879146144478f64).to_bits())))); + result.map(|_| ()) +} + +// Line 439 +fn c276_l439_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c276_l439_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((-421542582344268600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((1428505854670649100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-295093352936560340000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 442 +fn c277_l442_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c277_l442_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((1.8622957433108482f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010359363938125513f64).to_bits())))); + result.map(|_| ()) +} + +// Line 443 +fn c278_l443_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c278_l443_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008566632480779937f64).to_bits()), Value::F64((5381.2699796556235f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001591935084685746f64).to_bits())))); + result.map(|_| ()) +} + +// Line 444 +fn c279_l444_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c279_l444_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((-0.00000000000000000000000000000000000000000008196220919495565f64).to_bits()), Value::F64((-10406557086484777000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007876015911295176f64).to_bits())))); + result.map(|_| ()) +} + +// Line 445 +fn c280_l445_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c280_l445_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007052801866447111f64).to_bits()), Value::F64((-13767429405781133000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005122816800851397f64).to_bits())))); + result.map(|_| ()) +} + +// Line 446 +fn c281_l446_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c281_l446_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022655621734165475f64).to_bits()), Value::F64((133219932963494700000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017006180103974106f64).to_bits())))); + result.map(|_| ()) +} + +// Line 447 +fn c282_l447_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c282_l447_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004196304106554003f64).to_bits()), Value::F64((-9789327.297653636f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000042866113053139f64).to_bits())))); + result.map(|_| ()) +} + +// Line 450 +fn c283_l450_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c283_l450_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((1038860800000000000000000000.0f32).to_bits()), Value::F32((6211079500000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((167259300000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 451 +fn c284_l451_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c284_l451_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((1869033000000000000000000000.0f32).to_bits()), Value::F32((-112355730000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-0.00001663496f32).to_bits())))); + result.map(|_| ()) +} + +// Line 452 +fn c285_l452_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c285_l452_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((3290747200000000000000000.0f32).to_bits()), Value::F32((0.9064788f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((3630252700000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 453 +fn c286_l453_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c286_l453_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((-908946.56f32).to_bits()), Value::F32((-17034289000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000053359818f32).to_bits())))); + result.map(|_| ()) +} + +// Line 454 +fn c287_l454_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c287_l454_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((-0.00000000000024092477f32).to_bits()), Value::F32((-89840810000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000000000000000026816852f32).to_bits())))); + result.map(|_| ()) +} + +// Line 455 +fn c288_l455_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c288_l455_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((3910973045785834000.0f64).to_bits()), Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008392730733897136f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-46599529638070336000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 456 +fn c289_l456_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c289_l456_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((0.0000000000000000000000000000000000000008379351966732404f64).to_bits()), Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000021077277802048832f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-3975538039318286000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 457 +fn c290_l457_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c290_l457_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((4561142017854715000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((1500578067736849100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((3039589952.6465592f64).to_bits())))); + result.map(|_| ()) +} + +// Line 458 +fn c291_l458_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c291_l458_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((-6236072401827852000000000000000000000000000000000000000.0f64).to_bits()), Value::F64((83170632504609900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007497925907299316f64).to_bits())))); + result.map(|_| ()) +} + +// Line 459 +fn c292_l459_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c292_l459_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009757271330468098f64).to_bits()), Value::F64((-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000035613812243480865f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000002739743575824061f64).to_bits())))); + result.map(|_| ()) +} + +// Line 462 +fn c293_l462_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c293_l462_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((0.00000000000000001046256872449641f64).to_bits()), Value::F64((1.8150892711657447f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000005764217160391678f64).to_bits())))); + result.map(|_| ()) +} + +// Line 463 +fn c294_l463_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c294_l463_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((0.00000000000000000000000000000022038268106596436f64).to_bits()), Value::F64((-0.0000000000002859803943943555f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.0000000000000000007706216418530616f64).to_bits())))); + result.map(|_| ()) +} + +// Line 464 +fn c295_l464_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c295_l464_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((0.0000000000007596539988437179f64).to_bits()), Value::F64((0.00000000000000000000000000000000021055358831337124f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((3607889112357986600000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 465 +fn c296_l465_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c296_l465_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((1120696114500866900000000000.0f64).to_bits()), Value::F64((159713233802866500000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.007016927074960728f64).to_bits())))); + result.map(|_| ()) +} + +// Line 466 +fn c297_l466_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c297_l466_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((0.0006342142502301953f64).to_bits()), Value::F64((-6391950865520085.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-0.00000000000000000009922076429769178f64).to_bits())))); + result.map(|_| ()) +} + +// Line 469 +fn c298_l469_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c298_l469_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754942f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 470 +fn c299_l470_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c299_l470_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((0.000000000000000000000000000000000000011754942f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.9999999f32).to_bits())))); + result.map(|_| ()) +} + +// Line 471 +fn c300_l471_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c300_l471_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0000000000000002f64).to_bits())))); + result.map(|_| ()) +} + +// Line 472 +fn c301_l472_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c301_l472_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.9999999999999998f64).to_bits())))); + result.map(|_| ()) +} + +// Line 475 +fn c302_l475_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c302_l475_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((0.00000023841856f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 476 +fn c303_l476_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c303_l476_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((0.00000023841858f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 477 +fn c304_l477_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c304_l477_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((0.00000000000000044408920985006257f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 478 +fn c305_l478_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c305_l478_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((0.0000000000000004440892098500626f64).to_bits()), Value::F64((179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005f64).to_bits())))); + result.map(|_| ()) +} + +// Line 481 +fn c306_l481_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c306_l481_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000002938736f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 482 +fn c307_l482_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c307_l482_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000002938737f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((340282200000000000000000000000000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 483 +fn c308_l483_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c308_l483_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((1.0f64).to_bits()), Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005562684646268003f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64(f64::INFINITY.to_bits())))); + result.map(|_| ()) +} + +// Line 484 +fn c309_l484_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c309_l484_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((1.0f64).to_bits()), Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000556268464626801f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((179769313486231430000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 487 +fn c310_l487_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c310_l487_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((1.0f32).to_bits()), Value::F32((85070600000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754942f32).to_bits())))); + result.map(|_| ()) +} + +// Line 488 +fn c311_l488_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c311_l488_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((1.0f32).to_bits()), Value::F32((85070590000000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())))); + result.map(|_| ()) +} + +// Line 489 +fn c312_l489_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c312_l489_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((1.0f64).to_bits()), Value::F64((44942328371557910000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201f64).to_bits())))); + result.map(|_| ()) +} + +// Line 490 +fn c313_l490_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c313_l490_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((1.0f64).to_bits()), Value::F64((44942328371557900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014f64).to_bits())))); + result.map(|_| ()) +} + +// Line 500 +fn c314_l500_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c314_l500_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((1.0f32).to_bits()), Value::F32((3.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.33333334f32).to_bits())))); + result.map(|_| ()) +} + +// Line 501 +fn c315_l501_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c315_l501_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((3.0f32).to_bits()), Value::F32((9.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.33333334f32).to_bits())))); + result.map(|_| ()) +} + +// Line 502 +fn c316_l502_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c316_l502_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((9.0f32).to_bits()), Value::F32((27.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.33333334f32).to_bits())))); + result.map(|_| ()) +} + +// Line 503 +fn c317_l503_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c317_l503_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((1.0f64).to_bits()), Value::F64((3.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.3333333333333333f64).to_bits())))); + result.map(|_| ()) +} + +// Line 504 +fn c318_l504_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c318_l504_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((3.0f64).to_bits()), Value::F64((9.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.3333333333333333f64).to_bits())))); + result.map(|_| ()) +} + +// Line 505 +fn c319_l505_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c319_l505_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((9.0f64).to_bits()), Value::F64((27.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.3333333333333333f64).to_bits())))); + result.map(|_| ()) +} + +// Line 508 +fn c320_l508_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c320_l508_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((1.0000001f32).to_bits()), Value::F32((0.99999994f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0000002f32).to_bits())))); + result.map(|_| ()) +} + +// Line 509 +fn c321_l509_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c321_l509_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((0.99999994f32).to_bits()), Value::F32((1.0000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.9999998f32).to_bits())))); + result.map(|_| ()) +} + +// Line 510 +fn c322_l510_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c322_l510_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((1.0f32).to_bits()), Value::F32((0.99999994f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 511 +fn c323_l511_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c323_l511_action_invoke"); + let result = instance.call("f32.div", &[Value::F32((1.0f32).to_bits()), Value::F32((1.0000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.9999999f32).to_bits())))); + result.map(|_| ()) +} + +// Line 512 +fn c324_l512_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c324_l512_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((1.0000000000000002f64).to_bits()), Value::F64((0.9999999999999999f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0000000000000004f64).to_bits())))); + result.map(|_| ()) +} + +// Line 513 +fn c325_l513_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c325_l513_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((0.9999999999999999f64).to_bits()), Value::F64((1.0000000000000002f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.9999999999999997f64).to_bits())))); + result.map(|_| ()) +} + +// Line 514 +fn c326_l514_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c326_l514_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((1.0f64).to_bits()), Value::F64((0.9999999999999999f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0000000000000002f64).to_bits())))); + result.map(|_| ()) +} + +// Line 515 +fn c327_l515_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c327_l515_action_invoke"); + let result = instance.call("f64.div", &[Value::F64((1.0f64).to_bits()), Value::F64((1.0000000000000002f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.9999999999999998f64).to_bits())))); + result.map(|_| ()) +} + +// Line 519 +fn c328_l519_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c328_l519_action_invoke"); + let result = instance.call("f32.sqrt", &[Value::F32((171.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((13.076696f32).to_bits())))); + result.map(|_| ()) +} + +// Line 520 +fn c329_l520_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c329_l520_action_invoke"); + let result = instance.call("f32.sqrt", &[Value::F32((0.000000160795f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.00040099252f32).to_bits())))); + result.map(|_| ()) +} + +// Line 521 +fn c330_l521_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c330_l521_action_invoke"); + let result = instance.call("f64.sqrt", &[Value::F64((171.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((13.076696830622021f64).to_bits())))); + result.map(|_| ()) +} + +// Line 522 +fn c331_l522_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c331_l522_action_invoke"); + let result = instance.call("f64.sqrt", &[Value::F64((0.000000160795f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00040099251863345283f64).to_bits())))); + result.map(|_| ()) +} + +// Line 525 +fn c332_l525_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c332_l525_action_invoke"); + let result = instance.call("f64.sqrt", &[Value::F64((0.00000000000000000000000000000000000000000000000004316357580352844f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000020775845543209175f64).to_bits())))); + result.map(|_| ()) +} + +// Line 526 +fn c333_l526_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c333_l526_action_invoke"); + let result = instance.call("f64.sqrt", &[Value::F64((676253300479648500000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((822346216918183800000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 527 +fn c334_l527_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c334_l527_action_invoke"); + let result = instance.call("f64.sqrt", &[Value::F64((17485296624861996000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((4181542373916829400000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 528 +fn c335_l528_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c335_l528_action_invoke"); + let result = instance.call("f64.sqrt", &[Value::F64((0.000000000009593720960603523f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0000030973732355987585f64).to_bits())))); + result.map(|_| ()) +} + +// Line 529 +fn c336_l529_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c336_l529_action_invoke"); + let result = instance.call("f64.sqrt", &[Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006348452898717835f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000002519613640762773f64).to_bits())))); + result.map(|_| ()) +} + +// Line 533 +fn c337_l533_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c337_l533_action_invoke"); + let result = instance.call("f64.sqrt", &[Value::F64((0.9999999999999999f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.9999999999999999f64).to_bits())))); + result.map(|_| ()) +} + +// Line 536 +fn c338_l536_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c338_l536_action_invoke"); + let result = instance.call("f32.sqrt", &[Value::F32((0.12963942f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.36005473f32).to_bits())))); + result.map(|_| ()) +} + +// Line 537 +fn c339_l537_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c339_l537_action_invoke"); + let result = instance.call("f32.sqrt", &[Value::F32((2345875800000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1531625200000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 538 +fn c340_l538_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c340_l538_action_invoke"); + let result = instance.call("f32.sqrt", &[Value::F32((0.078786574f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.28068945f32).to_bits())))); + result.map(|_| ()) +} + +// Line 539 +fn c341_l539_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c341_l539_action_invoke"); + let result = instance.call("f32.sqrt", &[Value::F32((0.00000000000000000000051371026f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000022665177f32).to_bits())))); + result.map(|_| ()) +} + +// Line 540 +fn c342_l540_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c342_l540_action_invoke"); + let result = instance.call("f32.sqrt", &[Value::F32((0.00090167153f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.030027846f32).to_bits())))); + result.map(|_| ()) +} + +// Line 541 +fn c343_l541_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c343_l541_action_invoke"); + let result = instance.call("f64.sqrt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009591922760825561f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009793836204892116f64).to_bits())))); + result.map(|_| ()) +} + +// Line 542 +fn c344_l542_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c344_l542_action_invoke"); + let result = instance.call("f64.sqrt", &[Value::F64((935787535216400500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((30590644570136150000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 543 +fn c345_l543_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c345_l543_action_invoke"); + let result = instance.call("f64.sqrt", &[Value::F64((147706699783365580000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((12153464517715332000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 544 +fn c346_l544_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c346_l544_action_invoke"); + let result = instance.call("f64.sqrt", &[Value::F64((48800457180027890000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((6985732401117859.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 545 +fn c347_l545_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c347_l545_action_invoke"); + let result = instance.call("f64.sqrt", &[Value::F64((7618977687174540000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((2760249569726357000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 548 +fn c348_l548_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c348_l548_action_invoke"); + let result = instance.call("f32.sqrt", &[Value::F32((154481010.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((12429.039f32).to_bits())))); + result.map(|_| ()) +} + +// Line 549 +fn c349_l549_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c349_l549_action_invoke"); + let result = instance.call("f32.sqrt", &[Value::F32((0.00000000000000000000000000000000010471305f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.00000000000000001023294f32).to_bits())))); + result.map(|_| ()) +} + +// Line 550 +fn c350_l550_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c350_l550_action_invoke"); + let result = instance.call("f32.sqrt", &[Value::F32((0.00003790637f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.006156815f32).to_bits())))); + result.map(|_| ()) +} + +// Line 551 +fn c351_l551_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c351_l551_action_invoke"); + let result = instance.call("f32.sqrt", &[Value::F32((0.00000000000000000000000000000000000089607535f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0000000000000000009466126f32).to_bits())))); + result.map(|_| ()) +} + +// Line 552 +fn c352_l552_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c352_l552_action_invoke"); + let result = instance.call("f32.sqrt", &[Value::F32((0.0000000000000000000000000000000000001687712f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.00000000000000000041081773f32).to_bits())))); + result.map(|_| ()) +} + +// Line 553 +fn c353_l553_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c353_l553_action_invoke"); + let result = instance.call("f64.sqrt", &[Value::F64((316996264378909500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((563024212959717700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 554 +fn c354_l554_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c354_l554_action_invoke"); + let result = instance.call("f64.sqrt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040573669271847993f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020142906759414837f64).to_bits())))); + result.map(|_| ()) +} + +// Line 555 +fn c355_l555_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c355_l555_action_invoke"); + let result = instance.call("f64.sqrt", &[Value::F64((0.0000000015299861660588838f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00003911503759500793f64).to_bits())))); + result.map(|_| ()) +} + +// Line 556 +fn c356_l556_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c356_l556_action_invoke"); + let result = instance.call("f64.sqrt", &[Value::F64((0.0000000000000000000000000000000000000000000000000000000000000000000000002822766928951239f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0000000000000000000000000000000000005312971794533864f64).to_bits())))); + result.map(|_| ()) +} + +// Line 557 +fn c357_l557_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c357_l557_action_invoke"); + let result = instance.call("f64.sqrt", &[Value::F64((14375957727045067000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((119899782014168260000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 560 +fn c358_l560_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c358_l560_action_invoke"); + let result = instance.call("f32.sqrt", &[Value::F32((464023420000000000000000000000000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((681192700000000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 561 +fn c359_l561_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c359_l561_action_invoke"); + let result = instance.call("f32.sqrt", &[Value::F32((47536.133f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((218.02783f32).to_bits())))); + result.map(|_| ()) +} + +// Line 562 +fn c360_l562_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c360_l562_action_invoke"); + let result = instance.call("f32.sqrt", &[Value::F32((0.812613f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.9014505f32).to_bits())))); + result.map(|_| ()) +} + +// Line 563 +fn c361_l563_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c361_l563_action_invoke"); + let result = instance.call("f32.sqrt", &[Value::F32((0.000000000000000000000000009549605f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.00000000000009772208f32).to_bits())))); + result.map(|_| ()) +} + +// Line 564 +fn c362_l564_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c362_l564_action_invoke"); + let result = instance.call("f32.sqrt", &[Value::F32((0.000000000000000000000000000068856485f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000008297981f32).to_bits())))); + result.map(|_| ()) +} + +// Line 565 +fn c363_l565_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c363_l565_action_invoke"); + let result = instance.call("f64.sqrt", &[Value::F64((2349768917495332200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1532895599020146000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 566 +fn c364_l566_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c364_l566_action_invoke"); + let result = instance.call("f64.sqrt", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000029262574743429683f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0000000000000000000000000000000000000000000000000000000005409489323718985f64).to_bits())))); + result.map(|_| ()) +} + +// Line 567 +fn c365_l567_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c365_l567_action_invoke"); + let result = instance.call("f64.sqrt", &[Value::F64((377335087484490800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((19425114864126050000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 568 +fn c366_l568_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c366_l568_action_invoke"); + let result = instance.call("f64.sqrt", &[Value::F64((0.000000000000035498432023945234f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.00000018841027579180822f64).to_bits())))); + result.map(|_| ()) +} + +// Line 569 +fn c367_l569_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c367_l569_action_invoke"); + let result = instance.call("f64.sqrt", &[Value::F64((0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013747419336166767f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000011724938949165905f64).to_bits())))); + result.map(|_| ()) +} + +// Line 572 +fn c368_l572_assert_return_canonical_nan(instance: &mut Instance) { + println!("Executing function {}", "c368_l572_assert_return_canonical_nan"); + let result = instance.call("f64.sqrt", &[Value::F64((-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015535152663257847f64).to_bits())]).unwrap().expect("Missing result in c368_l572_assert_return_canonical_nan"); + assert!(match result { + Value::F32(fp) => f32::from_bits(fp).is_quiet_nan(), + Value::F64(fp) => f64::from_bits(fp).is_quiet_nan(), + _ => unimplemented!() + }) +} + +// Line 573 +fn c369_l573_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c369_l573_action_invoke"); + let result = instance.call("f64.sqrt", &[Value::F64((18763296348029700000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((4331662076851067.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 574 +fn c370_l574_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c370_l574_action_invoke"); + let result = instance.call("f64.sqrt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000274405777036165f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000523837548325972f64).to_bits())))); + result.map(|_| ()) +} + +// Line 575 +fn c371_l575_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c371_l575_action_invoke"); + let result = instance.call("f64.sqrt", &[Value::F64((0.000000000000000000000000000000000000000000000000000000000000000000000000000000000015613859952920445f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0000000000000000000000000000000000000000039514377070783294f64).to_bits())))); + result.map(|_| ()) +} + +// Line 576 +fn c372_l576_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c372_l576_action_invoke"); + let result = instance.call("f64.sqrt", &[Value::F64((619303768945071200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((24885814612848646000000000000000000000000000000000000000000000000000000000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 579 +fn c373_l579_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c373_l579_action_invoke"); + let result = instance.call("f32.sqrt", &[Value::F32((1.0000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 580 +fn c374_l580_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c374_l580_action_invoke"); + let result = instance.call("f32.sqrt", &[Value::F32((1.0000002f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0000001f32).to_bits())))); + result.map(|_| ()) +} + +// Line 581 +fn c375_l581_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c375_l581_action_invoke"); + let result = instance.call("f64.sqrt", &[Value::F64((1.0000000000000002f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 582 +fn c376_l582_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c376_l582_action_invoke"); + let result = instance.call("f64.sqrt", &[Value::F64((1.0000000000000004f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0000000000000002f64).to_bits())))); + result.map(|_| ()) +} + +// Line 585 +fn c377_l585_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c377_l585_action_invoke"); + let result = instance.call("f32.sqrt", &[Value::F32((0.9999999f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.99999994f32).to_bits())))); + result.map(|_| ()) +} + +// Line 586 +fn c378_l586_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c378_l586_action_invoke"); + let result = instance.call("f32.sqrt", &[Value::F32((0.9999998f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.9999999f32).to_bits())))); + result.map(|_| ()) +} + +// Line 587 +fn c379_l587_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c379_l587_action_invoke"); + let result = instance.call("f64.sqrt", &[Value::F64((0.9999999999999998f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.9999999999999999f64).to_bits())))); + result.map(|_| ()) +} + +// Line 588 +fn c380_l588_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c380_l588_action_invoke"); + let result = instance.call("f64.sqrt", &[Value::F64((0.9999999999999997f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.9999999999999998f64).to_bits())))); + result.map(|_| ()) +} + +// Line 592 +fn c381_l592_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c381_l592_action_invoke"); + let result = instance.call("f32.abs", &[Value::F32(f32::from_bits(2139156962) as u32)]); + let expected = f32::from_bits(2139156962); + 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 593 +fn c382_l593_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c382_l593_action_invoke"); + let result = instance.call("f32.abs", &[Value::F32(f32::from_bits(4286640610) as u32)]); + let expected = f32::from_bits(2139156962); + 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 594 +fn c383_l594_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c383_l594_action_invoke"); + let result = instance.call("f64.abs", &[Value::F64(f64::from_bits(9218868441285556843) as u64)]); + let expected = f64::from_bits(9218868441285556843); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 595 +fn c384_l595_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c384_l595_action_invoke"); + let result = instance.call("f64.abs", &[Value::F64(f64::from_bits(18442240478140332651) as u64)]); + let expected = f64::from_bits(9218868441285556843); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 597 +fn c385_l597_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c385_l597_action_invoke"); + let result = instance.call("f32.neg", &[Value::F32(f32::from_bits(2139156962) as u32)]); + let expected = f32::from_bits(4286640610); + 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 598 +fn c386_l598_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c386_l598_action_invoke"); + let result = instance.call("f32.neg", &[Value::F32(f32::from_bits(4286640610) as u32)]); + let expected = f32::from_bits(2139156962); + 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 599 +fn c387_l599_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c387_l599_action_invoke"); + let result = instance.call("f64.neg", &[Value::F64(f64::from_bits(9218868441285556843) as u64)]); + let expected = f64::from_bits(18442240478140332651); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 600 +fn c388_l600_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c388_l600_action_invoke"); + let result = instance.call("f64.neg", &[Value::F64(f64::from_bits(18442240478140332651) as u64)]); + let expected = f64::from_bits(9218868441285556843); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 602 +fn c389_l602_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c389_l602_action_invoke"); + let result = instance.call("f32.copysign", &[Value::F32(f32::from_bits(2139156962) as u32), Value::F32(f32::from_bits(2143289344) as u32)]); + let expected = f32::from_bits(2139156962); + 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 603 +fn c390_l603_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c390_l603_action_invoke"); + let result = instance.call("f32.copysign", &[Value::F32(f32::from_bits(2139156962) as u32), Value::F32(f32::from_bits(4290772992) as u32)]); + let expected = f32::from_bits(4286640610); + 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 604 +fn c391_l604_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c391_l604_action_invoke"); + let result = instance.call("f32.copysign", &[Value::F32(f32::from_bits(4286640610) as u32), Value::F32(f32::from_bits(2143289344) as u32)]); + let expected = f32::from_bits(2139156962); + 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 605 +fn c392_l605_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c392_l605_action_invoke"); + let result = instance.call("f32.copysign", &[Value::F32(f32::from_bits(4286640610) as u32), Value::F32(f32::from_bits(4290772992) as u32)]); + let expected = f32::from_bits(4286640610); + 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 606 +fn c393_l606_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c393_l606_action_invoke"); + let result = instance.call("f64.copysign", &[Value::F64(f64::from_bits(9218868441285556843) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + let expected = f64::from_bits(9218868441285556843); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 607 +fn c394_l607_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c394_l607_action_invoke"); + let result = instance.call("f64.copysign", &[Value::F64(f64::from_bits(9218868441285556843) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + let expected = f64::from_bits(18442240478140332651); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 608 +fn c395_l608_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c395_l608_action_invoke"); + let result = instance.call("f64.copysign", &[Value::F64(f64::from_bits(18442240478140332651) as u64), Value::F64(f64::from_bits(9221120237041090560) as u64)]); + let expected = f64::from_bits(9218868441285556843); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 609 +fn c396_l609_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c396_l609_action_invoke"); + let result = instance.call("f64.copysign", &[Value::F64(f64::from_bits(18442240478140332651) as u64), Value::F64(f64::from_bits(18444492273895866368) as u64)]); + let expected = f64::from_bits(18442240478140332651); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 612 +fn c397_l612_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c397_l612_action_invoke"); + let result = instance.call("f32.ceil", &[Value::F32((0.99999994f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 613 +fn c398_l613_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c398_l613_action_invoke"); + let result = instance.call("f32.ceil", &[Value::F32((1.0000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((2.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 614 +fn c399_l614_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c399_l614_action_invoke"); + let result = instance.call("f64.ceil", &[Value::F64((0.9999999999999999f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 615 +fn c400_l615_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c400_l615_action_invoke"); + let result = instance.call("f64.ceil", &[Value::F64((1.0000000000000002f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((2.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 618 +fn c401_l618_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c401_l618_action_invoke"); + let result = instance.call("f32.ceil", &[Value::F32((8388607.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((8388608.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 619 +fn c402_l619_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c402_l619_action_invoke"); + let result = instance.call("f32.ceil", &[Value::F32((-8388607.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-8388607.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 620 +fn c403_l620_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c403_l620_action_invoke"); + let result = instance.call("f64.ceil", &[Value::F64((4503599627370495.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((4503599627370496.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 621 +fn c404_l621_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c404_l621_action_invoke"); + let result = instance.call("f64.ceil", &[Value::F64((-4503599627370495.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-4503599627370495.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 625 +fn c405_l625_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c405_l625_action_invoke"); + let result = instance.call("f32.ceil", &[Value::F32((16777215.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((16777215.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 626 +fn c406_l626_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c406_l626_action_invoke"); + let result = instance.call("f32.ceil", &[Value::F32((-16777215.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-16777215.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 627 +fn c407_l627_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c407_l627_action_invoke"); + let result = instance.call("f64.ceil", &[Value::F64((9007199254740991.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((9007199254740991.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 628 +fn c408_l628_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c408_l628_action_invoke"); + let result = instance.call("f64.ceil", &[Value::F64((-9007199254740991.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-9007199254740991.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 631 +fn c409_l631_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c409_l631_action_invoke"); + let result = instance.call("f32.floor", &[Value::F32((-0.99999994f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 632 +fn c410_l632_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c410_l632_action_invoke"); + let result = instance.call("f32.floor", &[Value::F32((-1.0000001f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-2.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 633 +fn c411_l633_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c411_l633_action_invoke"); + let result = instance.call("f64.floor", &[Value::F64((-0.9999999999999999f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 634 +fn c412_l634_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c412_l634_action_invoke"); + let result = instance.call("f64.floor", &[Value::F64((-1.0000000000000002f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-2.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 637 +fn c413_l637_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c413_l637_action_invoke"); + let result = instance.call("f32.floor", &[Value::F32((-8388607.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-8388608.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 638 +fn c414_l638_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c414_l638_action_invoke"); + let result = instance.call("f32.floor", &[Value::F32((8388607.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((8388607.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 639 +fn c415_l639_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c415_l639_action_invoke"); + let result = instance.call("f64.floor", &[Value::F64((-4503599627370495.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-4503599627370496.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 640 +fn c416_l640_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c416_l640_action_invoke"); + let result = instance.call("f64.floor", &[Value::F64((4503599627370495.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((4503599627370495.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 644 +fn c417_l644_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c417_l644_action_invoke"); + let result = instance.call("f32.floor", &[Value::F32((88607.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((88607.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 645 +fn c418_l645_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c418_l645_action_invoke"); + let result = instance.call("f64.floor", &[Value::F64((88607.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((88607.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 648 +fn c419_l648_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c419_l648_action_invoke"); + let result = instance.call("f32.trunc", &[Value::F32((-8388607.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-8388607.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 649 +fn c420_l649_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c420_l649_action_invoke"); + let result = instance.call("f32.trunc", &[Value::F32((8388607.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((8388607.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 650 +fn c421_l650_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c421_l650_action_invoke"); + let result = instance.call("f64.trunc", &[Value::F64((-4503599627370495.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-4503599627370495.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 651 +fn c422_l651_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c422_l651_action_invoke"); + let result = instance.call("f64.trunc", &[Value::F64((4503599627370495.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((4503599627370495.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 656 +fn c423_l656_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c423_l656_action_invoke"); + let result = instance.call("f32.nearest", &[Value::F32((8388609.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((8388609.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 657 +fn c424_l657_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c424_l657_action_invoke"); + let result = instance.call("f32.nearest", &[Value::F32((8388610.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((8388610.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 658 +fn c425_l658_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c425_l658_action_invoke"); + let result = instance.call("f32.nearest", &[Value::F32((0.49999997f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 659 +fn c426_l659_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c426_l659_action_invoke"); + let result = instance.call("f32.nearest", &[Value::F32((281474960000000.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((281474960000000.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 660 +fn c427_l660_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c427_l660_action_invoke"); + let result = instance.call("f64.nearest", &[Value::F64((4503599627370497.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((4503599627370497.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 661 +fn c428_l661_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c428_l661_action_invoke"); + let result = instance.call("f64.nearest", &[Value::F64((4503599627370498.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((4503599627370498.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 662 +fn c429_l662_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c429_l662_action_invoke"); + let result = instance.call("f64.nearest", &[Value::F64((0.49999999999999994f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 663 +fn c430_l663_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c430_l663_action_invoke"); + let result = instance.call("f64.nearest", &[Value::F64((81129638414606670000000000000000.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((81129638414606670000000000000000.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 667 +fn c431_l667_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c431_l667_action_invoke"); + let result = instance.call("f32.nearest", &[Value::F32((4.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((4.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 668 +fn c432_l668_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c432_l668_action_invoke"); + let result = instance.call("f32.nearest", &[Value::F32((-4.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-4.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 669 +fn c433_l669_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c433_l669_action_invoke"); + let result = instance.call("f32.nearest", &[Value::F32((-3.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-4.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 670 +fn c434_l670_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c434_l670_action_invoke"); + let result = instance.call("f64.nearest", &[Value::F64((4.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((4.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 671 +fn c435_l671_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c435_l671_action_invoke"); + let result = instance.call("f64.nearest", &[Value::F64((-4.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-4.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 672 +fn c436_l672_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c436_l672_action_invoke"); + let result = instance.call("f64.nearest", &[Value::F64((-3.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-4.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 675 +fn c437_l675_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c437_l675_action_invoke"); + let result = instance.call("f32.nearest", &[Value::F32((-8388607.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((-8388608.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 676 +fn c438_l676_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c438_l676_action_invoke"); + let result = instance.call("f32.nearest", &[Value::F32((8388607.5f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((8388608.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 677 +fn c439_l677_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c439_l677_action_invoke"); + let result = instance.call("f64.nearest", &[Value::F64((-4503599627370495.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((-4503599627370496.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 678 +fn c440_l678_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c440_l678_action_invoke"); + let result = instance.call("f64.nearest", &[Value::F64((4503599627370495.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((4503599627370496.0f64).to_bits())))); + result.map(|_| ()) +} + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l50_action_invoke(&mut instance); + c2_l51_action_invoke(&mut instance); + c3_l55_action_invoke(&mut instance); + c4_l56_action_invoke(&mut instance); + c5_l57_action_invoke(&mut instance); + c6_l58_action_invoke(&mut instance); + c7_l61_action_invoke(&mut instance); + c8_l62_action_invoke(&mut instance); + c9_l67_action_invoke(&mut instance); + c10_l68_action_invoke(&mut instance); + c11_l72_action_invoke(&mut instance); + c12_l75_action_invoke(&mut instance); + c13_l78_action_invoke(&mut instance); + c14_l81_action_invoke(&mut instance); + c15_l82_action_invoke(&mut instance); + c16_l83_action_invoke(&mut instance); + c17_l84_action_invoke(&mut instance); + c18_l87_action_invoke(&mut instance); + c19_l88_action_invoke(&mut instance); + c20_l89_action_invoke(&mut instance); + c21_l90_action_invoke(&mut instance); + c22_l91_action_invoke(&mut instance); + c23_l92_action_invoke(&mut instance); + c24_l93_action_invoke(&mut instance); + c25_l94_action_invoke(&mut instance); + c26_l95_action_invoke(&mut instance); + c27_l96_action_invoke(&mut instance); + c28_l99_action_invoke(&mut instance); + c29_l100_action_invoke(&mut instance); + c30_l101_action_invoke(&mut instance); + c31_l102_action_invoke(&mut instance); + c32_l103_action_invoke(&mut instance); + c33_l104_action_invoke(&mut instance); + c34_l105_action_invoke(&mut instance); + c35_l106_action_invoke(&mut instance); + c36_l107_action_invoke(&mut instance); + c37_l108_action_invoke(&mut instance); + c38_l111_action_invoke(&mut instance); + c39_l112_action_invoke(&mut instance); + c40_l113_action_invoke(&mut instance); + c41_l114_action_invoke(&mut instance); + c42_l115_action_invoke(&mut instance); + c43_l116_action_invoke(&mut instance); + c44_l117_action_invoke(&mut instance); + c45_l118_action_invoke(&mut instance); + c46_l119_action_invoke(&mut instance); + c47_l120_action_invoke(&mut instance); + c48_l123_action_invoke(&mut instance); + c49_l124_action_invoke(&mut instance); + c50_l125_action_invoke(&mut instance); + c51_l126_action_invoke(&mut instance); + c52_l127_action_invoke(&mut instance); + c53_l130_action_invoke(&mut instance); + c54_l131_action_invoke(&mut instance); + c55_l132_action_invoke(&mut instance); + c56_l133_action_invoke(&mut instance); + c57_l134_action_invoke(&mut instance); + c58_l137_action_invoke(&mut instance); + c59_l138_action_invoke(&mut instance); + c60_l139_action_invoke(&mut instance); + c61_l140_action_invoke(&mut instance); + c62_l141_action_invoke(&mut instance); + c63_l142_action_invoke(&mut instance); + c64_l143_action_invoke(&mut instance); + c65_l144_action_invoke(&mut instance); + c66_l145_action_invoke(&mut instance); + c67_l146_action_invoke(&mut instance); + c68_l149_action_invoke(&mut instance); + c69_l150_action_invoke(&mut instance); + c70_l151_action_invoke(&mut instance); + c71_l152_action_invoke(&mut instance); + c72_l153_action_invoke(&mut instance); + c73_l154_action_invoke(&mut instance); + c74_l155_action_invoke(&mut instance); + c75_l156_action_invoke(&mut instance); + c76_l157_action_invoke(&mut instance); + c77_l158_action_invoke(&mut instance); + c78_l162_action_invoke(&mut instance); + c79_l163_action_invoke(&mut instance); + c80_l166_action_invoke(&mut instance); + c81_l167_action_invoke(&mut instance); + c82_l170_action_invoke(&mut instance); + c83_l171_action_invoke(&mut instance); + c84_l172_action_invoke(&mut instance); + c85_l173_action_invoke(&mut instance); + c86_l177_action_invoke(&mut instance); + c87_l178_action_invoke(&mut instance); + c88_l182_action_invoke(&mut instance); + c89_l183_action_invoke(&mut instance); + c90_l184_action_invoke(&mut instance); + c91_l185_action_invoke(&mut instance); + c92_l188_action_invoke(&mut instance); + c93_l189_action_invoke(&mut instance); + c94_l190_action_invoke(&mut instance); + c95_l191_action_invoke(&mut instance); + c96_l192_action_invoke(&mut instance); + c97_l193_action_invoke(&mut instance); + c98_l194_action_invoke(&mut instance); + c99_l195_action_invoke(&mut instance); + c100_l196_action_invoke(&mut instance); + c101_l197_action_invoke(&mut instance); + c102_l200_action_invoke(&mut instance); + c103_l201_action_invoke(&mut instance); + c104_l202_action_invoke(&mut instance); + c105_l203_action_invoke(&mut instance); + c106_l204_action_invoke(&mut instance); + c107_l205_action_invoke(&mut instance); + c108_l206_action_invoke(&mut instance); + c109_l207_action_invoke(&mut instance); + c110_l208_action_invoke(&mut instance); + c111_l209_action_invoke(&mut instance); + c112_l212_action_invoke(&mut instance); + c113_l213_action_invoke(&mut instance); + c114_l214_action_invoke(&mut instance); + c115_l215_action_invoke(&mut instance); + c116_l216_action_invoke(&mut instance); + c117_l217_action_invoke(&mut instance); + c118_l218_action_invoke(&mut instance); + c119_l219_action_invoke(&mut instance); + c120_l220_action_invoke(&mut instance); + c121_l221_action_invoke(&mut instance); + c122_l224_action_invoke(&mut instance); + c123_l225_action_invoke(&mut instance); + c124_l226_action_invoke(&mut instance); + c125_l227_action_invoke(&mut instance); + c126_l228_action_invoke(&mut instance); + c127_l231_action_invoke(&mut instance); + c128_l232_action_invoke(&mut instance); + c129_l233_action_invoke(&mut instance); + c130_l234_action_invoke(&mut instance); + c131_l235_action_invoke(&mut instance); + c132_l239_action_invoke(&mut instance); + c133_l240_action_invoke(&mut instance); + c134_l243_action_invoke(&mut instance); + c135_l244_action_invoke(&mut instance); + c136_l245_action_invoke(&mut instance); + c137_l246_action_invoke(&mut instance); + c138_l247_action_invoke(&mut instance); + c139_l248_action_invoke(&mut instance); + c140_l249_action_invoke(&mut instance); + c141_l250_action_invoke(&mut instance); + c142_l251_action_invoke(&mut instance); + c143_l252_action_invoke(&mut instance); + c144_l255_action_invoke(&mut instance); + c145_l256_action_invoke(&mut instance); + c146_l259_action_invoke(&mut instance); + c147_l260_action_invoke(&mut instance); + c148_l261_action_invoke(&mut instance); + c149_l262_action_invoke(&mut instance); + c150_l263_action_invoke(&mut instance); + c151_l264_action_invoke(&mut instance); + c152_l268_action_invoke(&mut instance); + c153_l269_action_invoke(&mut instance); + c154_l270_action_invoke(&mut instance); + c155_l271_action_invoke(&mut instance); + c156_l274_action_invoke(&mut instance); + c157_l275_action_invoke(&mut instance); + c158_l276_action_invoke(&mut instance); + c159_l277_action_invoke(&mut instance); + c160_l278_action_invoke(&mut instance); + c161_l279_action_invoke(&mut instance); + c162_l284_action_invoke(&mut instance); + c163_l285_action_invoke(&mut instance); + c164_l289_action_invoke(&mut instance); + c165_l290_action_invoke(&mut instance); + c166_l293_action_invoke(&mut instance); + c167_l294_action_invoke(&mut instance); + c168_l295_action_invoke(&mut instance); + c169_l296_action_invoke(&mut instance); + c170_l297_action_invoke(&mut instance); + c171_l298_action_invoke(&mut instance); + c172_l299_action_invoke(&mut instance); + c173_l300_action_invoke(&mut instance); + c174_l301_action_invoke(&mut instance); + c175_l302_action_invoke(&mut instance); + c176_l305_action_invoke(&mut instance); + c177_l306_action_invoke(&mut instance); + c178_l307_action_invoke(&mut instance); + c179_l308_action_invoke(&mut instance); + c180_l309_action_invoke(&mut instance); + c181_l310_action_invoke(&mut instance); + c182_l311_action_invoke(&mut instance); + c183_l312_action_invoke(&mut instance); + c184_l313_action_invoke(&mut instance); + c185_l314_action_invoke(&mut instance); + c186_l317_action_invoke(&mut instance); + c187_l318_action_invoke(&mut instance); + c188_l319_action_invoke(&mut instance); + c189_l320_action_invoke(&mut instance); + c190_l321_action_invoke(&mut instance); + c191_l322_action_invoke(&mut instance); + c192_l323_action_invoke(&mut instance); + c193_l324_action_invoke(&mut instance); + c194_l325_action_invoke(&mut instance); + c195_l326_action_invoke(&mut instance); + c196_l329_action_invoke(&mut instance); + c197_l330_action_invoke(&mut instance); + c198_l331_action_invoke(&mut instance); + c199_l332_action_invoke(&mut instance); + c200_l333_action_invoke(&mut instance); + c201_l336_action_invoke(&mut instance); + c202_l337_action_invoke(&mut instance); + c203_l338_action_invoke(&mut instance); + c204_l339_action_invoke(&mut instance); + c205_l340_action_invoke(&mut instance); + c206_l343_action_invoke(&mut instance); + c207_l344_action_invoke(&mut instance); + c208_l345_action_invoke(&mut instance); + c209_l346_action_invoke(&mut instance); + c210_l347_action_invoke(&mut instance); + c211_l350_action_invoke(&mut instance); + c212_l351_action_invoke(&mut instance); + c213_l352_action_invoke(&mut instance); + c214_l353_action_invoke(&mut instance); + c215_l356_action_invoke(&mut instance); + c216_l357_action_invoke(&mut instance); + c217_l358_action_invoke(&mut instance); + c218_l359_action_invoke(&mut instance); + c219_l362_action_invoke(&mut instance); + c220_l363_action_invoke(&mut instance); + c221_l364_action_invoke(&mut instance); + c222_l365_action_invoke(&mut instance); + c223_l368_action_invoke(&mut instance); + c224_l369_action_invoke(&mut instance); + c225_l370_action_invoke(&mut instance); + c226_l371_action_invoke(&mut instance); + c227_l375_action_invoke(&mut instance); + c228_l376_action_invoke(&mut instance); + c229_l379_action_invoke(&mut instance); + c230_l382_action_invoke(&mut instance); + c231_l383_action_invoke(&mut instance); + c232_l384_action_invoke(&mut instance); + c233_l385_action_invoke(&mut instance); + c234_l386_action_invoke(&mut instance); + c235_l387_action_invoke(&mut instance); + c236_l388_action_invoke(&mut instance); + c237_l389_action_invoke(&mut instance); + c238_l390_action_invoke(&mut instance); + c239_l391_action_invoke(&mut instance); + c240_l395_action_invoke(&mut instance); + c241_l396_action_invoke(&mut instance); + c242_l399_action_invoke(&mut instance); + c243_l400_action_invoke(&mut instance); + c244_l401_action_invoke(&mut instance); + c245_l402_action_invoke(&mut instance); + c246_l403_action_invoke(&mut instance); + c247_l404_action_invoke(&mut instance); + c248_l405_action_invoke(&mut instance); + c249_l406_action_invoke(&mut instance); + c250_l407_action_invoke(&mut instance); + c251_l408_action_invoke(&mut instance); + c252_l411_action_invoke(&mut instance); + c253_l412_action_invoke(&mut instance); + c254_l413_action_invoke(&mut instance); + c255_l414_action_invoke(&mut instance); + c256_l415_action_invoke(&mut instance); + c257_l416_action_invoke(&mut instance); + c258_l417_action_invoke(&mut instance); + c259_l418_action_invoke(&mut instance); + c260_l419_action_invoke(&mut instance); + c261_l420_action_invoke(&mut instance); + c262_l423_action_invoke(&mut instance); + c263_l424_action_invoke(&mut instance); + c264_l425_action_invoke(&mut instance); + c265_l426_action_invoke(&mut instance); + c266_l427_action_invoke(&mut instance); + c267_l428_action_invoke(&mut instance); + c268_l429_action_invoke(&mut instance); + c269_l430_action_invoke(&mut instance); + c270_l431_action_invoke(&mut instance); + c271_l432_action_invoke(&mut instance); + c272_l435_action_invoke(&mut instance); + c273_l436_action_invoke(&mut instance); + c274_l437_action_invoke(&mut instance); + c275_l438_action_invoke(&mut instance); + c276_l439_action_invoke(&mut instance); + c277_l442_action_invoke(&mut instance); + c278_l443_action_invoke(&mut instance); + c279_l444_action_invoke(&mut instance); + c280_l445_action_invoke(&mut instance); + c281_l446_action_invoke(&mut instance); + c282_l447_action_invoke(&mut instance); + c283_l450_action_invoke(&mut instance); + c284_l451_action_invoke(&mut instance); + c285_l452_action_invoke(&mut instance); + c286_l453_action_invoke(&mut instance); + c287_l454_action_invoke(&mut instance); + c288_l455_action_invoke(&mut instance); + c289_l456_action_invoke(&mut instance); + c290_l457_action_invoke(&mut instance); + c291_l458_action_invoke(&mut instance); + c292_l459_action_invoke(&mut instance); + c293_l462_action_invoke(&mut instance); + c294_l463_action_invoke(&mut instance); + c295_l464_action_invoke(&mut instance); + c296_l465_action_invoke(&mut instance); + c297_l466_action_invoke(&mut instance); + c298_l469_action_invoke(&mut instance); + c299_l470_action_invoke(&mut instance); + c300_l471_action_invoke(&mut instance); + c301_l472_action_invoke(&mut instance); + c302_l475_action_invoke(&mut instance); + c303_l476_action_invoke(&mut instance); + c304_l477_action_invoke(&mut instance); + c305_l478_action_invoke(&mut instance); + c306_l481_action_invoke(&mut instance); + c307_l482_action_invoke(&mut instance); + c308_l483_action_invoke(&mut instance); + c309_l484_action_invoke(&mut instance); + c310_l487_action_invoke(&mut instance); + c311_l488_action_invoke(&mut instance); + c312_l489_action_invoke(&mut instance); + c313_l490_action_invoke(&mut instance); + c314_l500_action_invoke(&mut instance); + c315_l501_action_invoke(&mut instance); + c316_l502_action_invoke(&mut instance); + c317_l503_action_invoke(&mut instance); + c318_l504_action_invoke(&mut instance); + c319_l505_action_invoke(&mut instance); + c320_l508_action_invoke(&mut instance); + c321_l509_action_invoke(&mut instance); + c322_l510_action_invoke(&mut instance); + c323_l511_action_invoke(&mut instance); + c324_l512_action_invoke(&mut instance); + c325_l513_action_invoke(&mut instance); + c326_l514_action_invoke(&mut instance); + c327_l515_action_invoke(&mut instance); + c328_l519_action_invoke(&mut instance); + c329_l520_action_invoke(&mut instance); + c330_l521_action_invoke(&mut instance); + c331_l522_action_invoke(&mut instance); + c332_l525_action_invoke(&mut instance); + c333_l526_action_invoke(&mut instance); + c334_l527_action_invoke(&mut instance); + c335_l528_action_invoke(&mut instance); + c336_l529_action_invoke(&mut instance); + c337_l533_action_invoke(&mut instance); + c338_l536_action_invoke(&mut instance); + c339_l537_action_invoke(&mut instance); + c340_l538_action_invoke(&mut instance); + c341_l539_action_invoke(&mut instance); + c342_l540_action_invoke(&mut instance); + c343_l541_action_invoke(&mut instance); + c344_l542_action_invoke(&mut instance); + c345_l543_action_invoke(&mut instance); + c346_l544_action_invoke(&mut instance); + c347_l545_action_invoke(&mut instance); + c348_l548_action_invoke(&mut instance); + c349_l549_action_invoke(&mut instance); + c350_l550_action_invoke(&mut instance); + c351_l551_action_invoke(&mut instance); + c352_l552_action_invoke(&mut instance); + c353_l553_action_invoke(&mut instance); + c354_l554_action_invoke(&mut instance); + c355_l555_action_invoke(&mut instance); + c356_l556_action_invoke(&mut instance); + c357_l557_action_invoke(&mut instance); + c358_l560_action_invoke(&mut instance); + c359_l561_action_invoke(&mut instance); + c360_l562_action_invoke(&mut instance); + c361_l563_action_invoke(&mut instance); + c362_l564_action_invoke(&mut instance); + c363_l565_action_invoke(&mut instance); + c364_l566_action_invoke(&mut instance); + c365_l567_action_invoke(&mut instance); + c366_l568_action_invoke(&mut instance); + c367_l569_action_invoke(&mut instance); + c368_l572_assert_return_canonical_nan(&mut instance); + c369_l573_action_invoke(&mut instance); + c370_l574_action_invoke(&mut instance); + c371_l575_action_invoke(&mut instance); + c372_l576_action_invoke(&mut instance); + c373_l579_action_invoke(&mut instance); + c374_l580_action_invoke(&mut instance); + c375_l581_action_invoke(&mut instance); + c376_l582_action_invoke(&mut instance); + c377_l585_action_invoke(&mut instance); + c378_l586_action_invoke(&mut instance); + c379_l587_action_invoke(&mut instance); + c380_l588_action_invoke(&mut instance); + c381_l592_action_invoke(&mut instance); + c382_l593_action_invoke(&mut instance); + c383_l594_action_invoke(&mut instance); + c384_l595_action_invoke(&mut instance); + c385_l597_action_invoke(&mut instance); + c386_l598_action_invoke(&mut instance); + c387_l599_action_invoke(&mut instance); + c388_l600_action_invoke(&mut instance); + c389_l602_action_invoke(&mut instance); + c390_l603_action_invoke(&mut instance); + c391_l604_action_invoke(&mut instance); + c392_l605_action_invoke(&mut instance); + c393_l606_action_invoke(&mut instance); + c394_l607_action_invoke(&mut instance); + c395_l608_action_invoke(&mut instance); + c396_l609_action_invoke(&mut instance); + c397_l612_action_invoke(&mut instance); + c398_l613_action_invoke(&mut instance); + c399_l614_action_invoke(&mut instance); + c400_l615_action_invoke(&mut instance); + c401_l618_action_invoke(&mut instance); + c402_l619_action_invoke(&mut instance); + c403_l620_action_invoke(&mut instance); + c404_l621_action_invoke(&mut instance); + c405_l625_action_invoke(&mut instance); + c406_l626_action_invoke(&mut instance); + c407_l627_action_invoke(&mut instance); + c408_l628_action_invoke(&mut instance); + c409_l631_action_invoke(&mut instance); + c410_l632_action_invoke(&mut instance); + c411_l633_action_invoke(&mut instance); + c412_l634_action_invoke(&mut instance); + c413_l637_action_invoke(&mut instance); + c414_l638_action_invoke(&mut instance); + c415_l639_action_invoke(&mut instance); + c416_l640_action_invoke(&mut instance); + c417_l644_action_invoke(&mut instance); + c418_l645_action_invoke(&mut instance); + c419_l648_action_invoke(&mut instance); + c420_l649_action_invoke(&mut instance); + c421_l650_action_invoke(&mut instance); + c422_l651_action_invoke(&mut instance); + c423_l656_action_invoke(&mut instance); + c424_l657_action_invoke(&mut instance); + c425_l658_action_invoke(&mut instance); + c426_l659_action_invoke(&mut instance); + c427_l660_action_invoke(&mut instance); + c428_l661_action_invoke(&mut instance); + c429_l662_action_invoke(&mut instance); + c430_l663_action_invoke(&mut instance); + c431_l667_action_invoke(&mut instance); + c432_l668_action_invoke(&mut instance); + c433_l669_action_invoke(&mut instance); + c434_l670_action_invoke(&mut instance); + c435_l671_action_invoke(&mut instance); + c436_l672_action_invoke(&mut instance); + c437_l675_action_invoke(&mut instance); + c438_l676_action_invoke(&mut instance); + c439_l677_action_invoke(&mut instance); + c440_l678_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/forward.rs b/lib/runtime/tests/spectests/forward.rs new file mode 100644 index 000000000..0d6925261 --- /dev/null +++ b/lib/runtime/tests/spectests/forward.rs @@ -0,0 +1,103 @@ +// 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/forward.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 1 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func (param i32) (result i32))) + (func (;0;) (type 0) (param i32) (result i32) + get_local 0 + i32.const 0 + i32.eq + if (result i32) ;; label = @1 + i32.const 1 + else + get_local 0 + i32.const 1 + i32.sub + call 1 + end) + (func (;1;) (type 0) (param i32) (result i32) + get_local 0 + i32.const 0 + i32.eq + if (result i32) ;; label = @1 + i32.const 0 + else + get_local 0 + i32.const 1 + i32.sub + call 0 + end) + (export \"even\" (func 0)) + (export \"odd\" (func 1))) + "; + 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 17 +fn c1_l17_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l17_action_invoke"); + let result = instance.call("even", &[Value::I32(13 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 18 +fn c2_l18_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l18_action_invoke"); + let result = instance.call("even", &[Value::I32(20 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 19 +fn c3_l19_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l19_action_invoke"); + let result = instance.call("odd", &[Value::I32(13 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 20 +fn c4_l20_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l20_action_invoke"); + let result = instance.call("odd", &[Value::I32(20 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l17_action_invoke(&mut instance); + c2_l18_action_invoke(&mut instance); + c3_l19_action_invoke(&mut instance); + c4_l20_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/func.rs b/lib/runtime/tests/spectests/func.rs new file mode 100644 index 000000000..ba9012caa --- /dev/null +++ b/lib/runtime/tests/spectests/func.rs @@ -0,0 +1,1514 @@ +// 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/func.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 3 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func)) + (type (;1;) (func)) + (type (;2;) (func (result i32))) + (type (;3;) (func (param i32))) + (type (;4;) (func (param i32 f64 i32) (result i32))) + (type (;5;) (func)) + (type (;6;) (func (param i32 f64 i64))) + (type (;7;) (func (param i32 f64))) + (type (;8;) (func (param i32 f32 i64 i32 f64))) + (type (;9;) (func (param i32 f32 i64 i32) (result i32))) + (type (;10;) (func (result i64))) + (type (;11;) (func (result f32))) + (type (;12;) (func (result f64))) + (type (;13;) (func (param i32 i32) (result i32))) + (type (;14;) (func (param i64 i64) (result i64))) + (type (;15;) (func (param f32 f32) (result f32))) + (type (;16;) (func (param f64 f64) (result f64))) + (type (;17;) (func (param f32 i32 i64 i32 f64 i32) (result f64))) + (type (;18;) (func (param i32) (result i32))) + (func (;0;) (type 0)) + (func (;1;) (type 0)) + (func (;2;) (type 0)) + (func (;3;) (type 0)) + (func (;4;) (type 0)) + (func (;5;) (type 0)) + (func (;6;) (type 0)) + (func (;7;) (type 0) + (local i32)) + (func (;8;) (type 0) + (local i32)) + (func (;9;) (type 0) + (local i32 f64 i64)) + (func (;10;) (type 0) + (local i32 f64)) + (func (;11;) (type 0) + (local i32 f32 i64 i32 f64)) + (func (;12;) (type 0)) + (func (;13;) (type 0)) + (func (;14;) (type 3) (param i32)) + (func (;15;) (type 3) (param i32)) + (func (;16;) (type 6) (param i32 f64 i64)) + (func (;17;) (type 7) (param i32 f64)) + (func (;18;) (type 8) (param i32 f32 i64 i32 f64)) + (func (;19;) (type 2) (result i32) + unreachable) + (func (;20;) (type 1)) + (func (;21;) (type 2) (result i32) + i32.const 0) + (func (;22;) (type 3) (param i32)) + (func (;23;) (type 4) (param i32 f64 i32) (result i32) + i32.const 0) + (func (;24;) (type 2) (result i32) + i32.const 0) + (func (;25;) (type 3) (param i32)) + (func (;26;) (type 4) (param i32 f64 i32) (result i32) + i32.const 0) + (func (;27;) (type 0)) + (func (;28;) (type 5)) + (func (;29;) (type 9) (param i32 f32 i64 i32) (result i32) + (local f32 i32 i64 i32 f64 i32) + unreachable + unreachable) + (func (;30;) (type 0) + (local f32 i32 i64 i32 f64 i32) + unreachable + unreachable) + (func (;31;) (type 2) (result i32) + (local i32 i32) + get_local 0) + (func (;32;) (type 10) (result i64) + (local i64 i64) + get_local 0) + (func (;33;) (type 11) (result f32) + (local f32 f32) + get_local 0) + (func (;34;) (type 12) (result f64) + (local f64 f64) + get_local 0) + (func (;35;) (type 2) (result i32) + (local i32 i32) + get_local 1) + (func (;36;) (type 10) (result i64) + (local i64 i64) + get_local 1) + (func (;37;) (type 11) (result f32) + (local f32 f32) + get_local 1) + (func (;38;) (type 12) (result f64) + (local f64 f64) + get_local 1) + (func (;39;) (type 12) (result f64) + (local f32 i32 i64 i32 f64 i32) + get_local 0 + f32.neg + drop + get_local 1 + i32.eqz + drop + get_local 2 + i64.eqz + drop + get_local 3 + i32.eqz + drop + get_local 4 + f64.neg + drop + get_local 5 + i32.eqz + drop + get_local 4) + (func (;40;) (type 13) (param i32 i32) (result i32) + get_local 0) + (func (;41;) (type 14) (param i64 i64) (result i64) + get_local 0) + (func (;42;) (type 15) (param f32 f32) (result f32) + get_local 0) + (func (;43;) (type 16) (param f64 f64) (result f64) + get_local 0) + (func (;44;) (type 13) (param i32 i32) (result i32) + get_local 1) + (func (;45;) (type 14) (param i64 i64) (result i64) + get_local 1) + (func (;46;) (type 15) (param f32 f32) (result f32) + get_local 1) + (func (;47;) (type 16) (param f64 f64) (result f64) + get_local 1) + (func (;48;) (type 17) (param f32 i32 i64 i32 f64 i32) (result f64) + get_local 0 + f32.neg + drop + get_local 1 + i32.eqz + drop + get_local 2 + i64.eqz + drop + get_local 3 + i32.eqz + drop + get_local 4 + f64.neg + drop + get_local 5 + i32.eqz + drop + get_local 4) + (func (;49;) (type 0)) + (func (;50;) (type 0) + call 0) + (func (;51;) (type 2) (result i32) + i32.const 77) + (func (;52;) (type 10) (result i64) + i64.const 7777) + (func (;53;) (type 11) (result f32) + f32.const 0x1.36ccccp+6 (;=77.7;)) + (func (;54;) (type 12) (result f64) + f64.const 0x1.37147ae147ae1p+6 (;=77.77;)) + (func (;55;) (type 0) + block ;; label = @1 + call 0 + call 0 + end) + (func (;56;) (type 2) (result i32) + block (result i32) ;; label = @1 + call 0 + i32.const 77 + end) + (func (;57;) (type 0) + return) + (func (;58;) (type 2) (result i32) + i32.const 78 + return) + (func (;59;) (type 10) (result i64) + i64.const 7878 + return) + (func (;60;) (type 11) (result f32) + f32.const 0x1.3accccp+6 (;=78.7;) + return) + (func (;61;) (type 12) (result f64) + f64.const 0x1.3b1eb851eb852p+6 (;=78.78;) + return) + (func (;62;) (type 2) (result i32) + block (result i32) ;; label = @1 + call 0 + i32.const 77 + end + return) + (func (;63;) (type 0) + br 0 (;@0;)) + (func (;64;) (type 2) (result i32) + i32.const 79 + br 0 (;@0;)) + (func (;65;) (type 10) (result i64) + i64.const 7979 + br 0 (;@0;)) + (func (;66;) (type 11) (result f32) + f32.const 0x1.3f999ap+6 (;=79.9;) + br 0 (;@0;)) + (func (;67;) (type 12) (result f64) + f64.const 0x1.3f28f5c28f5c3p+6 (;=79.79;) + br 0 (;@0;)) + (func (;68;) (type 2) (result i32) + block (result i32) ;; label = @1 + call 0 + i32.const 77 + end + br 0 (;@0;)) + (func (;69;) (type 3) (param i32) + get_local 0 + br_if 0 (;@0;)) + (func (;70;) (type 18) (param i32) (result i32) + i32.const 50 + get_local 0 + br_if 0 (;@0;) + drop + i32.const 51) + (func (;71;) (type 3) (param i32) + get_local 0 + br_table 0 (;@0;) 0 (;@0;) 0 (;@0;)) + (func (;72;) (type 18) (param i32) (result i32) + i32.const 50 + get_local 0 + br_table 0 (;@0;) 0 (;@0;) + i32.const 51) + (func (;73;) (type 3) (param i32) + block ;; label = @1 + get_local 0 + br_table 0 (;@1;) 1 (;@0;) 0 (;@1;) + end) + (func (;74;) (type 18) (param i32) (result i32) + block (result i32) ;; label = @1 + i32.const 50 + get_local 0 + br_table 0 (;@1;) 1 (;@0;) 0 (;@1;) + i32.const 51 + end + i32.const 2 + i32.add) + (func (;75;) (type 2) (result i32) + (local i32) + get_local 0) + (func (;76;) (type 10) (result i64) + (local i64) + get_local 0) + (func (;77;) (type 11) (result f32) + (local f32) + get_local 0) + (func (;78;) (type 12) (result f64) + (local f64) + get_local 0) + (export \"f\" (func 2)) + (export \"g\" (func 4)) + (export \"type-use-1\" (func 20)) + (export \"type-use-2\" (func 21)) + (export \"type-use-3\" (func 22)) + (export \"type-use-4\" (func 23)) + (export \"type-use-5\" (func 24)) + (export \"type-use-6\" (func 25)) + (export \"type-use-7\" (func 26)) + (export \"local-first-i32\" (func 31)) + (export \"local-first-i64\" (func 32)) + (export \"local-first-f32\" (func 33)) + (export \"local-first-f64\" (func 34)) + (export \"local-second-i32\" (func 35)) + (export \"local-second-i64\" (func 36)) + (export \"local-second-f32\" (func 37)) + (export \"local-second-f64\" (func 38)) + (export \"local-mixed\" (func 39)) + (export \"param-first-i32\" (func 40)) + (export \"param-first-i64\" (func 41)) + (export \"param-first-f32\" (func 42)) + (export \"param-first-f64\" (func 43)) + (export \"param-second-i32\" (func 44)) + (export \"param-second-i64\" (func 45)) + (export \"param-second-f32\" (func 46)) + (export \"param-second-f64\" (func 47)) + (export \"param-mixed\" (func 48)) + (export \"empty\" (func 49)) + (export \"value-void\" (func 50)) + (export \"value-i32\" (func 51)) + (export \"value-i64\" (func 52)) + (export \"value-f32\" (func 53)) + (export \"value-f64\" (func 54)) + (export \"value-block-void\" (func 55)) + (export \"value-block-i32\" (func 56)) + (export \"return-empty\" (func 57)) + (export \"return-i32\" (func 58)) + (export \"return-i64\" (func 59)) + (export \"return-f32\" (func 60)) + (export \"return-f64\" (func 61)) + (export \"return-block-i32\" (func 62)) + (export \"break-empty\" (func 63)) + (export \"break-i32\" (func 64)) + (export \"break-i64\" (func 65)) + (export \"break-f32\" (func 66)) + (export \"break-f64\" (func 67)) + (export \"break-block-i32\" (func 68)) + (export \"break-br_if-empty\" (func 69)) + (export \"break-br_if-num\" (func 70)) + (export \"break-br_table-empty\" (func 71)) + (export \"break-br_table-num\" (func 72)) + (export \"break-br_table-nested-empty\" (func 73)) + (export \"break-br_table-nested-num\" (func 74)) + (export \"init-local-i32\" (func 75)) + (export \"init-local-i64\" (func 76)) + (export \"init-local-f32\" (func 77)) + (export \"init-local-f64\" (func 78))) + "; + 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 171 +fn c1_l171_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l171_action_invoke"); + let result = instance.call("type-use-1", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 172 +fn c2_l172_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l172_action_invoke"); + let result = instance.call("type-use-2", &[]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 173 +fn c3_l173_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l173_action_invoke"); + let result = instance.call("type-use-3", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 175 +fn c4_l175_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l175_action_invoke"); + let result = instance.call("type-use-4", &[Value::I32(1 as i32), Value::F64((1.0f64).to_bits()), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 178 +fn c5_l178_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l178_action_invoke"); + let result = instance.call("type-use-5", &[]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 179 +fn c6_l179_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l179_action_invoke"); + let result = instance.call("type-use-6", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 181 +fn c7_l181_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l181_action_invoke"); + let result = instance.call("type-use-7", &[Value::I32(1 as i32), Value::F64((1.0f64).to_bits()), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 185 +fn c8_l185_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l185_action_invoke"); + let result = instance.call("local-first-i32", &[]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 186 +fn c9_l186_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l186_action_invoke"); + let result = instance.call("local-first-i64", &[]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 187 +fn c10_l187_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c10_l187_action_invoke"); + let result = instance.call("local-first-f32", &[]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 188 +fn c11_l188_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c11_l188_action_invoke"); + let result = instance.call("local-first-f64", &[]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 189 +fn c12_l189_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c12_l189_action_invoke"); + let result = instance.call("local-second-i32", &[]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 190 +fn c13_l190_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c13_l190_action_invoke"); + let result = instance.call("local-second-i64", &[]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 191 +fn c14_l191_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c14_l191_action_invoke"); + let result = instance.call("local-second-f32", &[]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 192 +fn c15_l192_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c15_l192_action_invoke"); + let result = instance.call("local-second-f64", &[]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 193 +fn c16_l193_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c16_l193_action_invoke"); + let result = instance.call("local-mixed", &[]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 196 +fn c17_l196_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c17_l196_action_invoke"); + let result = instance.call("param-first-i32", &[Value::I32(2 as i32), Value::I32(3 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 199 +fn c18_l199_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c18_l199_action_invoke"); + let result = instance.call("param-first-i64", &[Value::I64(2 as i64), Value::I64(3 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(2 as i64)))); + result.map(|_| ()) +} + +// Line 202 +fn c19_l202_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c19_l202_action_invoke"); + let result = instance.call("param-first-f32", &[Value::F32((2.0f32).to_bits()), Value::F32((3.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((2.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 205 +fn c20_l205_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c20_l205_action_invoke"); + let result = instance.call("param-first-f64", &[Value::F64((2.0f64).to_bits()), Value::F64((3.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((2.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 208 +fn c21_l208_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c21_l208_action_invoke"); + let result = instance.call("param-second-i32", &[Value::I32(2 as i32), Value::I32(3 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 211 +fn c22_l211_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c22_l211_action_invoke"); + let result = instance.call("param-second-i64", &[Value::I64(2 as i64), Value::I64(3 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(3 as i64)))); + result.map(|_| ()) +} + +// Line 214 +fn c23_l214_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c23_l214_action_invoke"); + let result = instance.call("param-second-f32", &[Value::F32((2.0f32).to_bits()), Value::F32((3.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((3.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 217 +fn c24_l217_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c24_l217_action_invoke"); + let result = instance.call("param-second-f64", &[Value::F64((2.0f64).to_bits()), Value::F64((3.0f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((3.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 221 +fn c25_l221_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c25_l221_action_invoke"); + let result = instance.call("param-mixed", &[Value::F32((1.0f32).to_bits()), Value::I32(2 as i32), Value::I64(3 as i64), Value::I32(4 as i32), Value::F64((5.5f64).to_bits()), Value::I32(6 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((5.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 228 +fn c26_l228_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c26_l228_action_invoke"); + let result = instance.call("empty", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 229 +fn c27_l229_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c27_l229_action_invoke"); + let result = instance.call("value-void", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 230 +fn c28_l230_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c28_l230_action_invoke"); + let result = instance.call("value-i32", &[]); + assert_eq!(result, Ok(Some(Value::I32(77 as i32)))); + result.map(|_| ()) +} + +// Line 231 +fn c29_l231_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c29_l231_action_invoke"); + let result = instance.call("value-i64", &[]); + assert_eq!(result, Ok(Some(Value::I64(7777 as i64)))); + result.map(|_| ()) +} + +// Line 232 +fn c30_l232_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c30_l232_action_invoke"); + let result = instance.call("value-f32", &[]); + assert_eq!(result, Ok(Some(Value::F32((77.7f32).to_bits())))); + result.map(|_| ()) +} + +// Line 233 +fn c31_l233_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c31_l233_action_invoke"); + let result = instance.call("value-f64", &[]); + assert_eq!(result, Ok(Some(Value::F64((77.77f64).to_bits())))); + result.map(|_| ()) +} + +// Line 234 +fn c32_l234_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c32_l234_action_invoke"); + let result = instance.call("value-block-void", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 235 +fn c33_l235_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c33_l235_action_invoke"); + let result = instance.call("value-block-i32", &[]); + assert_eq!(result, Ok(Some(Value::I32(77 as i32)))); + result.map(|_| ()) +} + +// Line 237 +fn c34_l237_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c34_l237_action_invoke"); + let result = instance.call("return-empty", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 238 +fn c35_l238_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c35_l238_action_invoke"); + let result = instance.call("return-i32", &[]); + assert_eq!(result, Ok(Some(Value::I32(78 as i32)))); + result.map(|_| ()) +} + +// Line 239 +fn c36_l239_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c36_l239_action_invoke"); + let result = instance.call("return-i64", &[]); + assert_eq!(result, Ok(Some(Value::I64(7878 as i64)))); + result.map(|_| ()) +} + +// Line 240 +fn c37_l240_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c37_l240_action_invoke"); + let result = instance.call("return-f32", &[]); + assert_eq!(result, Ok(Some(Value::F32((78.7f32).to_bits())))); + result.map(|_| ()) +} + +// Line 241 +fn c38_l241_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c38_l241_action_invoke"); + let result = instance.call("return-f64", &[]); + assert_eq!(result, Ok(Some(Value::F64((78.78f64).to_bits())))); + result.map(|_| ()) +} + +// Line 242 +fn c39_l242_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c39_l242_action_invoke"); + let result = instance.call("return-block-i32", &[]); + assert_eq!(result, Ok(Some(Value::I32(77 as i32)))); + result.map(|_| ()) +} + +// Line 244 +fn c40_l244_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c40_l244_action_invoke"); + let result = instance.call("break-empty", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 245 +fn c41_l245_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c41_l245_action_invoke"); + let result = instance.call("break-i32", &[]); + assert_eq!(result, Ok(Some(Value::I32(79 as i32)))); + result.map(|_| ()) +} + +// Line 246 +fn c42_l246_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c42_l246_action_invoke"); + let result = instance.call("break-i64", &[]); + assert_eq!(result, Ok(Some(Value::I64(7979 as i64)))); + result.map(|_| ()) +} + +// Line 247 +fn c43_l247_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c43_l247_action_invoke"); + let result = instance.call("break-f32", &[]); + assert_eq!(result, Ok(Some(Value::F32((79.9f32).to_bits())))); + result.map(|_| ()) +} + +// Line 248 +fn c44_l248_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c44_l248_action_invoke"); + let result = instance.call("break-f64", &[]); + assert_eq!(result, Ok(Some(Value::F64((79.79f64).to_bits())))); + result.map(|_| ()) +} + +// Line 249 +fn c45_l249_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c45_l249_action_invoke"); + let result = instance.call("break-block-i32", &[]); + assert_eq!(result, Ok(Some(Value::I32(77 as i32)))); + result.map(|_| ()) +} + +// Line 251 +fn c46_l251_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c46_l251_action_invoke"); + let result = instance.call("break-br_if-empty", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 252 +fn c47_l252_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c47_l252_action_invoke"); + let result = instance.call("break-br_if-empty", &[Value::I32(2 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 253 +fn c48_l253_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c48_l253_action_invoke"); + let result = instance.call("break-br_if-num", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(51 as i32)))); + result.map(|_| ()) +} + +// Line 254 +fn c49_l254_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c49_l254_action_invoke"); + let result = instance.call("break-br_if-num", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(50 as i32)))); + result.map(|_| ()) +} + +// Line 256 +fn c50_l256_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c50_l256_action_invoke"); + let result = instance.call("break-br_table-empty", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 257 +fn c51_l257_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c51_l257_action_invoke"); + let result = instance.call("break-br_table-empty", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 258 +fn c52_l258_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c52_l258_action_invoke"); + let result = instance.call("break-br_table-empty", &[Value::I32(5 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 259 +fn c53_l259_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c53_l259_action_invoke"); + let result = instance.call("break-br_table-empty", &[Value::I32(-1 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 260 +fn c54_l260_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c54_l260_action_invoke"); + let result = instance.call("break-br_table-num", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(50 as i32)))); + result.map(|_| ()) +} + +// Line 261 +fn c55_l261_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c55_l261_action_invoke"); + let result = instance.call("break-br_table-num", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(50 as i32)))); + result.map(|_| ()) +} + +// Line 262 +fn c56_l262_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c56_l262_action_invoke"); + let result = instance.call("break-br_table-num", &[Value::I32(10 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(50 as i32)))); + result.map(|_| ()) +} + +// Line 263 +fn c57_l263_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c57_l263_action_invoke"); + let result = instance.call("break-br_table-num", &[Value::I32(-100 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(50 as i32)))); + result.map(|_| ()) +} + +// Line 264 +fn c58_l264_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c58_l264_action_invoke"); + let result = instance.call("break-br_table-nested-empty", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 265 +fn c59_l265_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c59_l265_action_invoke"); + let result = instance.call("break-br_table-nested-empty", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 266 +fn c60_l266_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c60_l266_action_invoke"); + let result = instance.call("break-br_table-nested-empty", &[Value::I32(3 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 267 +fn c61_l267_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c61_l267_action_invoke"); + let result = instance.call("break-br_table-nested-empty", &[Value::I32(-2 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 269 +fn c62_l269_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c62_l269_action_invoke"); + let result = instance.call("break-br_table-nested-num", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(52 as i32)))); + result.map(|_| ()) +} + +// Line 272 +fn c63_l272_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c63_l272_action_invoke"); + let result = instance.call("break-br_table-nested-num", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(50 as i32)))); + result.map(|_| ()) +} + +// Line 275 +fn c64_l275_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c64_l275_action_invoke"); + let result = instance.call("break-br_table-nested-num", &[Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(52 as i32)))); + result.map(|_| ()) +} + +// Line 278 +fn c65_l278_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c65_l278_action_invoke"); + let result = instance.call("break-br_table-nested-num", &[Value::I32(-3 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(52 as i32)))); + result.map(|_| ()) +} + +// Line 281 +fn c66_l281_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c66_l281_action_invoke"); + let result = instance.call("init-local-i32", &[]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 282 +fn c67_l282_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c67_l282_action_invoke"); + let result = instance.call("init-local-i64", &[]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 283 +fn c68_l283_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c68_l283_action_invoke"); + let result = instance.call("init-local-f32", &[]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 284 +fn c69_l284_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c69_l284_action_invoke"); + let result = instance.call("init-local-f64", &[]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 289 + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l171_action_invoke(&mut instance); + c2_l172_action_invoke(&mut instance); + c3_l173_action_invoke(&mut instance); + c4_l175_action_invoke(&mut instance); + c5_l178_action_invoke(&mut instance); + c6_l179_action_invoke(&mut instance); + c7_l181_action_invoke(&mut instance); + c8_l185_action_invoke(&mut instance); + c9_l186_action_invoke(&mut instance); + c10_l187_action_invoke(&mut instance); + c11_l188_action_invoke(&mut instance); + c12_l189_action_invoke(&mut instance); + c13_l190_action_invoke(&mut instance); + c14_l191_action_invoke(&mut instance); + c15_l192_action_invoke(&mut instance); + c16_l193_action_invoke(&mut instance); + c17_l196_action_invoke(&mut instance); + c18_l199_action_invoke(&mut instance); + c19_l202_action_invoke(&mut instance); + c20_l205_action_invoke(&mut instance); + c21_l208_action_invoke(&mut instance); + c22_l211_action_invoke(&mut instance); + c23_l214_action_invoke(&mut instance); + c24_l217_action_invoke(&mut instance); + c25_l221_action_invoke(&mut instance); + c26_l228_action_invoke(&mut instance); + c27_l229_action_invoke(&mut instance); + c28_l230_action_invoke(&mut instance); + c29_l231_action_invoke(&mut instance); + c30_l232_action_invoke(&mut instance); + c31_l233_action_invoke(&mut instance); + c32_l234_action_invoke(&mut instance); + c33_l235_action_invoke(&mut instance); + c34_l237_action_invoke(&mut instance); + c35_l238_action_invoke(&mut instance); + c36_l239_action_invoke(&mut instance); + c37_l240_action_invoke(&mut instance); + c38_l241_action_invoke(&mut instance); + c39_l242_action_invoke(&mut instance); + c40_l244_action_invoke(&mut instance); + c41_l245_action_invoke(&mut instance); + c42_l246_action_invoke(&mut instance); + c43_l247_action_invoke(&mut instance); + c44_l248_action_invoke(&mut instance); + c45_l249_action_invoke(&mut instance); + c46_l251_action_invoke(&mut instance); + c47_l252_action_invoke(&mut instance); + c48_l253_action_invoke(&mut instance); + c49_l254_action_invoke(&mut instance); + c50_l256_action_invoke(&mut instance); + c51_l257_action_invoke(&mut instance); + c52_l258_action_invoke(&mut instance); + c53_l259_action_invoke(&mut instance); + c54_l260_action_invoke(&mut instance); + c55_l261_action_invoke(&mut instance); + c56_l262_action_invoke(&mut instance); + c57_l263_action_invoke(&mut instance); + c58_l264_action_invoke(&mut instance); + c59_l265_action_invoke(&mut instance); + c60_l266_action_invoke(&mut instance); + c61_l267_action_invoke(&mut instance); + c62_l269_action_invoke(&mut instance); + c63_l272_action_invoke(&mut instance); + c64_l275_action_invoke(&mut instance); + c65_l278_action_invoke(&mut instance); + c66_l281_action_invoke(&mut instance); + c67_l282_action_invoke(&mut instance); + c68_l283_action_invoke(&mut instance); + c69_l284_action_invoke(&mut instance); +} +fn create_module_2() -> Box { + let module_str = "(module + (type (;0;) (func (param i32))) + (type (;1;) (func (result f64))) + (type (;2;) (func)) + (func (;0;) (type 1) (result f64) + f64.const 0x0p+0 (;=0;)) + (func (;1;) (type 0) (param i32)) + (func (;2;) (type 0) (param i32)) + (func (;3;) (type 1) (result f64) + f64.const 0x0p+0 (;=0;)) + (func (;4;) (type 2) + i32.const 0 + call 2 + call 3 + drop)) + "; + 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_2(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 303 +#[test] +fn c71_l303_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 1, 127, 0, 96, 0, 1, 124, 3, 5, 4, 1, 0, 1, 2, 10, 31, 4, 11, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 11, 2, 0, 11, 11, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 11, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 315 + +#[test] +fn test_module_2() { + let mut instance = create_module_2(); + // We group the calls together + start_module_2(&mut instance); +} +fn create_module_3() -> Box { + let module_str = "(module + (type (;0;) (func)) + (type (;1;) (func)) + (type (;2;) (func (param i64 i64 f64 i64 f64 i64 f32 i32))) + (type (;3;) (func (param f64 i64 f64 i64 f64 i64 f32 i32))) + (func (;0;) (type 0)) + (func (;1;) (type 3) (param f64 i64 f64 i64 f64 i64 f32 i32)) + (func (;2;) (type 0)) + (func (;3;) (type 3) (param f64 i64 f64 i64 f64 i64 f32 i32)) + (func (;4;) (type 3) (param f64 i64 f64 i64 f64 i64 f32 i32)) + (func (;5;) (type 2) (param i64 i64 f64 i64 f64 i64 f32 i32)) + (func (;6;) (type 2) (param i64 i64 f64 i64 f64 i64 f32 i32)) + (func (;7;) (type 0) + i32.const 1 + call_indirect (type 0) + i32.const 4 + call_indirect (type 0)) + (func (;8;) (type 0) + f64.const 0x0p+0 (;=0;) + i64.const 0 + f64.const 0x0p+0 (;=0;) + i64.const 0 + f64.const 0x0p+0 (;=0;) + i64.const 0 + f32.const 0x0p+0 (;=0;) + i32.const 0 + i32.const 0 + call_indirect (type 3) + f64.const 0x0p+0 (;=0;) + i64.const 0 + f64.const 0x0p+0 (;=0;) + i64.const 0 + f64.const 0x0p+0 (;=0;) + i64.const 0 + f32.const 0x0p+0 (;=0;) + i32.const 0 + i32.const 2 + call_indirect (type 3) + f64.const 0x0p+0 (;=0;) + i64.const 0 + f64.const 0x0p+0 (;=0;) + i64.const 0 + f64.const 0x0p+0 (;=0;) + i64.const 0 + f32.const 0x0p+0 (;=0;) + i32.const 0 + i32.const 3 + call_indirect (type 3)) + (func (;9;) (type 0) + i32.const 1 + call_indirect (type 1)) + (func (;10;) (type 0) + i64.const 0 + i64.const 0 + f64.const 0x0p+0 (;=0;) + i64.const 0 + f64.const 0x0p+0 (;=0;) + i64.const 0 + f32.const 0x0p+0 (;=0;) + i32.const 0 + i32.const 5 + call_indirect (type 2) + i64.const 0 + i64.const 0 + f64.const 0x0p+0 (;=0;) + i64.const 0 + f64.const 0x0p+0 (;=0;) + i64.const 0 + f32.const 0x0p+0 (;=0;) + i32.const 0 + i32.const 6 + call_indirect (type 2)) + (table (;0;) 7 7 anyfunc) + (export \"signature-explicit-reused\" (func 7)) + (export \"signature-implicit-reused\" (func 8)) + (export \"signature-explicit-duplicate\" (func 9)) + (export \"signature-implicit-duplicate\" (func 10)) + (elem (;0;) (i32.const 0) 4 2 1 4 0 5 6)) + "; + 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_3(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 378 +fn c73_l378_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c73_l378_action_invoke"); + let result = instance.call("signature-explicit-reused", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 379 +fn c74_l379_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c74_l379_action_invoke"); + let result = instance.call("signature-implicit-reused", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 380 +fn c75_l380_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c75_l380_action_invoke"); + let result = instance.call("signature-explicit-duplicate", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 381 +fn c76_l381_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c76_l381_action_invoke"); + let result = instance.call("signature-implicit-duplicate", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 387 +#[test] +fn c77_l387_assert_malformed() { + let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 102, 117, 110, 99, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 394 +#[test] +fn c78_l394_assert_malformed() { + let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 401 +#[test] +fn c79_l401_assert_malformed() { + let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 408 +#[test] +fn c80_l408_assert_malformed() { + let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 415 +#[test] +fn c81_l415_assert_malformed() { + let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 422 +#[test] +fn c82_l422_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 429 +#[test] +fn c83_l429_assert_malformed() { + let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 41, 41, 40, 102, 117, 110, 99, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 436 +#[test] +fn c84_l436_assert_malformed() { + let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 102, 117, 110, 99, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 443 +#[test] +fn c85_l443_assert_malformed() { + let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 102, 117, 110, 99, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 450 +#[test] +fn c86_l450_assert_malformed() { + let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 102, 117, 110, 99, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 117, 110, 114, 101, 97, 99, 104, 97, 98, 108, 101, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 461 +#[test] +fn c87_l461_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 8, 1, 6, 1, 1, 127, 32, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 465 +#[test] +fn c88_l465_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 1, 1, 125, 32, 0, 69, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 469 +#[test] +fn c89_l469_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 11, 1, 9, 2, 1, 124, 1, 126, 32, 1, 154, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 477 +#[test] +fn c90_l477_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 127, 1, 126, 3, 2, 1, 0, 10, 6, 1, 4, 0, 32, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 481 +#[test] +fn c91_l481_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 125, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 32, 0, 69, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 485 +#[test] +fn c92_l485_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 2, 124, 126, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 32, 1, 154, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 493 +#[test] +fn c93_l493_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 0, 2, 127, 127, 3, 2, 1, 0, 10, 5, 1, 3, 0, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 497 +#[test] +fn c94_l497_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 0, 2, 127, 127, 3, 2, 1, 0, 10, 5, 1, 3, 0, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 506 +#[test] +fn c95_l506_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 4, 1, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 510 +#[test] +fn c96_l510_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 4, 1, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 514 +#[test] +fn c97_l514_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 4, 1, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 518 +#[test] +fn c98_l518_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 4, 1, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 523 +#[test] +fn c99_l523_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 5, 1, 3, 0, 1, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 529 +#[test] +fn c100_l529_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 6, 1, 4, 0, 65, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 535 +#[test] +fn c101_l535_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 9, 1, 7, 0, 67, 0, 0, 0, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 542 +#[test] +fn c102_l542_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 5, 1, 3, 0, 15, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 548 +#[test] +fn c103_l548_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 6, 1, 4, 0, 1, 15, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 554 +#[test] +fn c104_l554_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 15, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 561 +#[test] +fn c105_l561_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 7, 1, 5, 0, 15, 65, 1, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 567 +#[test] +fn c106_l567_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 8, 1, 6, 0, 1, 15, 65, 1, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 573 +#[test] +fn c107_l573_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 9, 1, 7, 0, 66, 1, 15, 65, 1, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 579 +#[test] +fn c108_l579_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 10, 1, 8, 0, 66, 1, 15, 65, 1, 15, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 586 +#[test] +fn c109_l586_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 6, 1, 4, 0, 12, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 592 +#[test] +fn c110_l592_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 11, 1, 9, 0, 67, 0, 0, 0, 0, 12, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 598 +#[test] +fn c111_l598_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 8, 1, 6, 0, 12, 0, 65, 1, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 604 +#[test] +fn c112_l604_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 10, 1, 8, 0, 66, 1, 12, 0, 65, 1, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 610 +#[test] +fn c113_l610_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 1, 12, 0, 65, 1, 12, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 617 +#[test] +fn c114_l617_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 64, 12, 1, 11, 65, 1, 12, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 623 +#[test] +fn c115_l623_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 64, 1, 12, 1, 11, 65, 1, 12, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 629 +#[test] +fn c116_l629_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 64, 66, 1, 12, 1, 11, 65, 1, 12, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 639 +#[test] +fn c117_l639_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 110, 111, 112, 41, 32, 40, 108, 111, 99, 97, 108, 32, 105, 51, 50, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 643 +#[test] +fn c118_l643_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 110, 111, 112, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 647 +#[test] +fn c119_l647_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 110, 111, 112, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 651 +#[test] +fn c120_l651_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 108, 111, 99, 97, 108, 32, 105, 51, 50, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 655 +#[test] +fn c121_l655_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 108, 111, 99, 97, 108, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 103, 101, 116, 95, 108, 111, 99, 97, 108, 32, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 659 +#[test] +fn c122_l659_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 103, 101, 116, 95, 108, 111, 99, 97, 108, 32, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +#[test] +fn test_module_3() { + let mut instance = create_module_3(); + // We group the calls together + start_module_3(&mut instance); + c73_l378_action_invoke(&mut instance); + c74_l379_action_invoke(&mut instance); + c75_l380_action_invoke(&mut instance); + c76_l381_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/func_ptrs.rs b/lib/runtime/tests/spectests/func_ptrs.rs new file mode 100644 index 000000000..fbd5e8546 --- /dev/null +++ b/lib/runtime/tests/spectests/func_ptrs.rs @@ -0,0 +1,470 @@ +// 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/func_ptrs.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 1 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func)) + (type (;1;) (func)) + (type (;2;) (func)) + (type (;3;) (func (result i32))) + (type (;4;) (func (result i32))) + (type (;5;) (func (param i32) (result i32))) + (type (;6;) (func (param i32))) + (import \"spectest\" \"print_i32\" (func (;0;) (type 6))) + (func (;1;) (type 0)) + (func (;2;) (type 1)) + (func (;3;) (type 4) (result i32) + i32.const 13) + (func (;4;) (type 5) (param i32) (result i32) + get_local 0 + i32.const 1 + i32.add) + (func (;5;) (type 5) (param i32) (result i32) + get_local 0 + i32.const 2 + i32.sub) + (func (;6;) (type 6) (param i32) + get_local 0 + call 0) + (export \"one\" (func 3)) + (export \"two\" (func 4)) + (export \"three\" (func 5)) + (export \"four\" (func 6))) + "; + 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 27 +fn c1_l27_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l27_action_invoke"); + let result = instance.call("one", &[]); + assert_eq!(result, Ok(Some(Value::I32(13 as i32)))); + result.map(|_| ()) +} + +// Line 28 +fn c2_l28_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l28_action_invoke"); + let result = instance.call("two", &[Value::I32(13 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(14 as i32)))); + result.map(|_| ()) +} + +// Line 29 +fn c3_l29_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l29_action_invoke"); + let result = instance.call("three", &[Value::I32(13 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(11 as i32)))); + result.map(|_| ()) +} + +// Line 30 +fn c4_l30_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l30_action_invoke"); + let result = instance.call("four", &[Value::I32(83 as i32)]); + + result.map(|_| ()) +} + +// Line 32 +#[test] +fn c5_l32_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 9, 6, 1, 0, 65, 0, 11, 0]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 33 +#[test] +fn c6_l33_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 9, 7, 1, 0, 65, 0, 11, 1, 0, 10, 4, 1, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 36 +#[test] +fn c7_l36_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 1, 9, 6, 1, 0, 66, 0, 11, 0]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 40 +#[test] +fn c8_l40_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 1, 9, 7, 1, 0, 65, 0, 104, 11, 0]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 44 +#[test] +fn c9_l44_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 1, 9, 5, 1, 0, 1, 11, 0]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 48 +#[test] +fn c10_l48_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 3, 2, 1, 42, 10, 4, 1, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 49 +#[test] +fn c11_l49_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 2, 22, 1, 8, 115, 112, 101, 99, 116, 101, 115, 116, 9, 112, 114, 105, 110, 116, 95, 105, 51, 50, 0, 43]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 51 + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l27_action_invoke(&mut instance); + c2_l28_action_invoke(&mut instance); + c3_l29_action_invoke(&mut instance); + c4_l30_action_invoke(&mut instance); +} +fn create_module_2() -> Box { + let module_str = "(module + (type (;0;) (func (result i32))) + (type (;1;) (func (result i32))) + (type (;2;) (func (param i32) (result i32))) + (func (;0;) (type 0) (result i32) + i32.const 1) + (func (;1;) (type 0) (result i32) + i32.const 2) + (func (;2;) (type 0) (result i32) + i32.const 3) + (func (;3;) (type 1) (result i32) + i32.const 4) + (func (;4;) (type 1) (result i32) + i32.const 5) + (func (;5;) (type 2) (param i32) (result i32) + get_local 0 + call_indirect (type 0)) + (func (;6;) (type 2) (param i32) (result i32) + get_local 0 + call_indirect (type 1)) + (table (;0;) 7 7 anyfunc) + (export \"callt\" (func 5)) + (export \"callu\" (func 6)) + (elem (;0;) (i32.const 0) 0 1 2 3 4 0 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_2(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 71 +fn c13_l71_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c13_l71_action_invoke"); + let result = instance.call("callt", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 72 +fn c14_l72_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c14_l72_action_invoke"); + let result = instance.call("callt", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 73 +fn c15_l73_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c15_l73_action_invoke"); + let result = instance.call("callt", &[Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 74 +fn c16_l74_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c16_l74_action_invoke"); + let result = instance.call("callt", &[Value::I32(3 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(4 as i32)))); + result.map(|_| ()) +} + +// Line 75 +fn c17_l75_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c17_l75_action_invoke"); + let result = instance.call("callt", &[Value::I32(4 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(5 as i32)))); + result.map(|_| ()) +} + +// Line 76 +fn c18_l76_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c18_l76_action_invoke"); + let result = instance.call("callt", &[Value::I32(5 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 77 +fn c19_l77_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c19_l77_action_invoke"); + let result = instance.call("callt", &[Value::I32(6 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 78 +fn c20_l78_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c20_l78_action_invoke"); + let result = instance.call("callt", &[Value::I32(7 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c20_l78_assert_trap() { + let mut instance = create_module_2(); + let result = c20_l78_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 79 +fn c21_l79_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c21_l79_action_invoke"); + let result = instance.call("callt", &[Value::I32(100 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c21_l79_assert_trap() { + let mut instance = create_module_2(); + let result = c21_l79_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 80 +fn c22_l80_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c22_l80_action_invoke"); + let result = instance.call("callt", &[Value::I32(-1 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c22_l80_assert_trap() { + let mut instance = create_module_2(); + let result = c22_l80_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 82 +fn c23_l82_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c23_l82_action_invoke"); + let result = instance.call("callu", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 83 +fn c24_l83_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c24_l83_action_invoke"); + let result = instance.call("callu", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 84 +fn c25_l84_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c25_l84_action_invoke"); + let result = instance.call("callu", &[Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 85 +fn c26_l85_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c26_l85_action_invoke"); + let result = instance.call("callu", &[Value::I32(3 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(4 as i32)))); + result.map(|_| ()) +} + +// Line 86 +fn c27_l86_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c27_l86_action_invoke"); + let result = instance.call("callu", &[Value::I32(4 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(5 as i32)))); + result.map(|_| ()) +} + +// Line 87 +fn c28_l87_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c28_l87_action_invoke"); + let result = instance.call("callu", &[Value::I32(5 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 88 +fn c29_l88_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c29_l88_action_invoke"); + let result = instance.call("callu", &[Value::I32(6 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 89 +fn c30_l89_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c30_l89_action_invoke"); + let result = instance.call("callu", &[Value::I32(7 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c30_l89_assert_trap() { + let mut instance = create_module_2(); + let result = c30_l89_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 90 +fn c31_l90_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c31_l90_action_invoke"); + let result = instance.call("callu", &[Value::I32(100 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c31_l90_assert_trap() { + let mut instance = create_module_2(); + let result = c31_l90_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 91 +fn c32_l91_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c32_l91_action_invoke"); + let result = instance.call("callu", &[Value::I32(-1 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c32_l91_assert_trap() { + let mut instance = create_module_2(); + let result = c32_l91_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 93 + +#[test] +fn test_module_2() { + let mut instance = create_module_2(); + // We group the calls together + start_module_2(&mut instance); + c13_l71_action_invoke(&mut instance); + c14_l72_action_invoke(&mut instance); + c15_l73_action_invoke(&mut instance); + c16_l74_action_invoke(&mut instance); + c17_l75_action_invoke(&mut instance); + c18_l76_action_invoke(&mut instance); + c19_l77_action_invoke(&mut instance); + c23_l82_action_invoke(&mut instance); + c24_l83_action_invoke(&mut instance); + c25_l84_action_invoke(&mut instance); + c26_l85_action_invoke(&mut instance); + c27_l86_action_invoke(&mut instance); + c28_l87_action_invoke(&mut instance); + c29_l88_action_invoke(&mut instance); +} +fn create_module_3() -> Box { + let module_str = "(module + (type (;0;) (func (result i32))) + (type (;1;) (func (param i32) (result i32))) + (func (;0;) (type 0) (result i32) + i32.const 1) + (func (;1;) (type 0) (result i32) + i32.const 2) + (func (;2;) (type 1) (param i32) (result i32) + get_local 0 + call_indirect (type 0)) + (table (;0;) 2 2 anyfunc) + (export \"callt\" (func 2)) + (elem (;0;) (i32.const 0) 0 1)) + "; + 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_3(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 105 +fn c34_l105_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c34_l105_action_invoke"); + let result = instance.call("callt", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 106 +fn c35_l106_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c35_l106_action_invoke"); + let result = instance.call("callt", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +#[test] +fn test_module_3() { + let mut instance = create_module_3(); + // We group the calls together + start_module_3(&mut instance); + c34_l105_action_invoke(&mut instance); + c35_l106_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/get_local.rs b/lib/runtime/tests/spectests/get_local.rs new file mode 100644 index 000000000..c2eca471e --- /dev/null +++ b/lib/runtime/tests/spectests/get_local.rs @@ -0,0 +1,327 @@ +// 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/get_local.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 3 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func (result i32))) + (type (;1;) (func (result i64))) + (type (;2;) (func (result f32))) + (type (;3;) (func (result f64))) + (type (;4;) (func (param i32) (result i32))) + (type (;5;) (func (param i64) (result i64))) + (type (;6;) (func (param f32) (result f32))) + (type (;7;) (func (param f64) (result f64))) + (type (;8;) (func (param i64 f32 f64 i32 i32))) + (type (;9;) (func (param i64 f32 f64 i32 i32) (result f64))) + (func (;0;) (type 0) (result i32) + (local i32) + get_local 0) + (func (;1;) (type 1) (result i64) + (local i64) + get_local 0) + (func (;2;) (type 2) (result f32) + (local f32) + get_local 0) + (func (;3;) (type 3) (result f64) + (local f64) + get_local 0) + (func (;4;) (type 4) (param i32) (result i32) + get_local 0) + (func (;5;) (type 5) (param i64) (result i64) + get_local 0) + (func (;6;) (type 6) (param f32) (result f32) + get_local 0) + (func (;7;) (type 7) (param f64) (result f64) + get_local 0) + (func (;8;) (type 8) (param i64 f32 f64 i32 i32) + (local f32 i64 i64 f64) + get_local 0 + i64.eqz + drop + get_local 1 + f32.neg + drop + get_local 2 + f64.neg + drop + get_local 3 + i32.eqz + drop + get_local 4 + i32.eqz + drop + get_local 5 + f32.neg + drop + get_local 6 + i64.eqz + drop + get_local 7 + i64.eqz + drop + get_local 8 + f64.neg + drop) + (func (;9;) (type 9) (param i64 f32 f64 i32 i32) (result f64) + (local f32 i64 i64 f64) + f32.const 0x1.6p+2 (;=5.5;) + set_local 5 + i64.const 6 + set_local 6 + f64.const 0x1p+3 (;=8;) + set_local 8 + get_local 0 + f64.convert_u/i64 + get_local 1 + f64.promote/f32 + get_local 2 + get_local 3 + f64.convert_u/i32 + get_local 4 + f64.convert_s/i32 + get_local 5 + f64.promote/f32 + get_local 6 + f64.convert_u/i64 + get_local 7 + f64.convert_u/i64 + get_local 8 + f64.add + f64.add + f64.add + f64.add + f64.add + f64.add + f64.add + f64.add) + (export \"type-local-i32\" (func 0)) + (export \"type-local-i64\" (func 1)) + (export \"type-local-f32\" (func 2)) + (export \"type-local-f64\" (func 3)) + (export \"type-param-i32\" (func 4)) + (export \"type-param-i64\" (func 5)) + (export \"type-param-f32\" (func 6)) + (export \"type-param-f64\" (func 7)) + (export \"type-mixed\" (func 8)) + (export \"read\" (func 9))) + "; + 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 64 +fn c1_l64_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l64_action_invoke"); + let result = instance.call("type-local-i32", &[]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 65 +fn c2_l65_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l65_action_invoke"); + let result = instance.call("type-local-i64", &[]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 66 +fn c3_l66_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l66_action_invoke"); + let result = instance.call("type-local-f32", &[]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 67 +fn c4_l67_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l67_action_invoke"); + let result = instance.call("type-local-f64", &[]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 69 +fn c5_l69_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l69_action_invoke"); + let result = instance.call("type-param-i32", &[Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 70 +fn c6_l70_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l70_action_invoke"); + let result = instance.call("type-param-i64", &[Value::I64(3 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(3 as i64)))); + result.map(|_| ()) +} + +// Line 71 +fn c7_l71_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l71_action_invoke"); + let result = instance.call("type-param-f32", &[Value::F32((4.4f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((4.4f32).to_bits())))); + result.map(|_| ()) +} + +// Line 72 +fn c8_l72_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l72_action_invoke"); + let result = instance.call("type-param-f64", &[Value::F64((5.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((5.5f64).to_bits())))); + result.map(|_| ()) +} + +// Line 75 +fn c9_l75_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l75_action_invoke"); + let result = instance.call("type-mixed", &[Value::I64(1 as i64), Value::F32((2.2f32).to_bits()), Value::F64((3.3f64).to_bits()), Value::I32(4 as i32), Value::I32(5 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 81 +fn c10_l81_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c10_l81_action_invoke"); + let result = instance.call("read", &[Value::I64(1 as i64), Value::F32((2.0f32).to_bits()), Value::F64((3.3f64).to_bits()), Value::I32(4 as i32), Value::I32(5 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((34.8f64).to_bits())))); + result.map(|_| ()) +} + +// Line 91 +#[test] +fn c11_l91_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 8, 1, 6, 1, 1, 127, 32, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 95 +#[test] +fn c12_l95_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 1, 1, 125, 32, 0, 69, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 99 +#[test] +fn c13_l99_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 11, 1, 9, 2, 1, 124, 1, 126, 32, 1, 154, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 107 +#[test] +fn c14_l107_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 127, 1, 126, 3, 2, 1, 0, 10, 6, 1, 4, 0, 32, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 111 +#[test] +fn c15_l111_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 125, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 32, 0, 69, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 115 +#[test] +fn c16_l115_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 2, 124, 126, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 32, 1, 154, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 123 +#[test] +fn c17_l123_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 10, 1, 8, 2, 1, 127, 1, 126, 32, 3, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 127 +#[test] +fn c18_l127_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 2, 1, 127, 1, 126, 32, 247, 164, 234, 6, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 132 +#[test] +fn c19_l132_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 2, 127, 126, 0, 3, 2, 1, 0, 10, 6, 1, 4, 0, 32, 2, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 136 +#[test] +fn c20_l136_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 14, 1, 12, 2, 1, 127, 1, 126, 32, 247, 242, 206, 212, 2, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 141 +#[test] +fn c21_l141_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 127, 0, 3, 2, 1, 0, 10, 10, 1, 8, 2, 1, 127, 1, 126, 32, 3, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 145 +#[test] +fn c22_l145_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 126, 0, 3, 2, 1, 0, 10, 13, 1, 11, 2, 1, 127, 1, 126, 32, 247, 168, 153, 102, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l64_action_invoke(&mut instance); + c2_l65_action_invoke(&mut instance); + c3_l66_action_invoke(&mut instance); + c4_l67_action_invoke(&mut instance); + c5_l69_action_invoke(&mut instance); + c6_l70_action_invoke(&mut instance); + c7_l71_action_invoke(&mut instance); + c8_l72_action_invoke(&mut instance); + c9_l75_action_invoke(&mut instance); + c10_l81_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/globals.rs b/lib/runtime/tests/spectests/globals.rs new file mode 100644 index 000000000..21059009c --- /dev/null +++ b/lib/runtime/tests/spectests/globals.rs @@ -0,0 +1,910 @@ +// 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/globals.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 4 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func (param i32 i32) (result i32))) + (type (;1;) (func (result i32))) + (type (;2;) (func (result i64))) + (type (;3;) (func (param i32))) + (type (;4;) (func (param i64))) + (type (;5;) (func (result f32))) + (type (;6;) (func (result f64))) + (type (;7;) (func (param f32))) + (type (;8;) (func (param f64))) + (type (;9;) (func)) + (type (;10;) (func (param i32) (result i32))) + (func (;0;) (type 1) (result i32) + get_global 0) + (func (;1;) (type 2) (result i64) + get_global 3) + (func (;2;) (type 1) (result i32) + get_global 4) + (func (;3;) (type 2) (result i64) + get_global 7) + (func (;4;) (type 3) (param i32) + get_local 0 + set_global 4) + (func (;5;) (type 4) (param i64) + get_local 0 + set_global 7) + (func (;6;) (type 5) (result f32) + get_global 1) + (func (;7;) (type 6) (result f64) + get_global 2) + (func (;8;) (type 5) (result f32) + get_global 5) + (func (;9;) (type 6) (result f64) + get_global 6) + (func (;10;) (type 7) (param f32) + get_local 0 + set_global 5) + (func (;11;) (type 8) (param f64) + get_local 0 + set_global 6) + (func (;12;) (type 9)) + (func (;13;) (type 1) (result i32) + get_global 4 + i32.const 2 + i32.const 3 + select) + (func (;14;) (type 1) (result i32) + i32.const 2 + get_global 4 + i32.const 3 + select) + (func (;15;) (type 1) (result i32) + i32.const 2 + i32.const 3 + get_global 4 + select) + (func (;16;) (type 1) (result i32) + loop (result i32) ;; label = @1 + get_global 4 + call 12 + call 12 + end) + (func (;17;) (type 1) (result i32) + loop (result i32) ;; label = @1 + call 12 + get_global 4 + call 12 + end) + (func (;18;) (type 1) (result i32) + loop (result i32) ;; label = @1 + call 12 + call 12 + get_global 4 + end) + (func (;19;) (type 1) (result i32) + get_global 4 + if (result i32) ;; label = @1 + call 12 + i32.const 2 + else + call 12 + i32.const 3 + end) + (func (;20;) (type 1) (result i32) + i32.const 1 + if (result i32) ;; label = @1 + get_global 4 + else + i32.const 2 + end) + (func (;21;) (type 1) (result i32) + i32.const 0 + if (result i32) ;; label = @1 + i32.const 2 + else + get_global 4 + end) + (func (;22;) (type 1) (result i32) + block (result i32) ;; label = @1 + get_global 4 + i32.const 2 + br_if 0 (;@1;) + i32.const 3 + return + end) + (func (;23;) (type 1) (result i32) + block (result i32) ;; label = @1 + i32.const 2 + get_global 4 + br_if 0 (;@1;) + i32.const 3 + return + end) + (func (;24;) (type 1) (result i32) + block (result i32) ;; label = @1 + get_global 4 + i32.const 2 + br_table 0 (;@1;) 0 (;@1;) + end) + (func (;25;) (type 1) (result i32) + block (result i32) ;; label = @1 + i32.const 2 + get_global 4 + br_table 0 (;@1;) 0 (;@1;) + end) + (func (;26;) (type 0) (param i32 i32) (result i32) + get_local 0) + (func (;27;) (type 1) (result i32) + block (result i32) ;; label = @1 + get_global 4 + i32.const 2 + i32.const 0 + call_indirect (type 0) + end) + (func (;28;) (type 1) (result i32) + block (result i32) ;; label = @1 + i32.const 2 + get_global 4 + i32.const 0 + call_indirect (type 0) + end) + (func (;29;) (type 1) (result i32) + block (result i32) ;; label = @1 + i32.const 2 + i32.const 0 + get_global 4 + call_indirect (type 0) + end) + (func (;30;) (type 9) + get_global 4 + i32.const 1 + i32.store) + (func (;31;) (type 9) + i32.const 0 + get_global 4 + i32.store) + (func (;32;) (type 1) (result i32) + get_global 4 + i32.load) + (func (;33;) (type 1) (result i32) + get_global 4 + memory.grow) + (func (;34;) (type 10) (param i32) (result i32) + get_local 0) + (func (;35;) (type 1) (result i32) + get_global 4 + call 34) + (func (;36;) (type 1) (result i32) + get_global 4 + return) + (func (;37;) (type 9) + get_global 4 + drop) + (func (;38;) (type 1) (result i32) + block (result i32) ;; label = @1 + get_global 4 + br 0 (;@1;) + end) + (func (;39;) (type 10) (param i32) (result i32) + get_global 4 + set_local 0 + get_local 0) + (func (;40;) (type 10) (param i32) (result i32) + get_global 4 + tee_local 0) + (func (;41;) (type 1) (result i32) + get_global 4 + set_global 4 + get_global 4) + (func (;42;) (type 1) (result i32) + get_global 4 + i32.eqz) + (func (;43;) (type 1) (result i32) + get_global 4 + get_global 4 + i32.mul) + (func (;44;) (type 1) (result i32) + get_global 0 + i32.const 1 + i32.gt_u) + (table (;0;) 1 1 anyfunc) + (memory (;0;) 1) + (global (;0;) i32 (i32.const -2)) + (global (;1;) f32 (f32.const -0x1.8p+1 (;=-3;))) + (global (;2;) f64 (f64.const -0x1p+2 (;=-4;))) + (global (;3;) i64 (i64.const -5)) + (global (;4;) (mut i32) (i32.const -12)) + (global (;5;) (mut f32) (f32.const -0x1.ap+3 (;=-13;))) + (global (;6;) (mut f64) (f64.const -0x1.cp+3 (;=-14;))) + (global (;7;) (mut i64) (i64.const -15)) + (export \"get-a\" (func 0)) + (export \"get-b\" (func 1)) + (export \"get-x\" (func 2)) + (export \"get-y\" (func 3)) + (export \"set-x\" (func 4)) + (export \"set-y\" (func 5)) + (export \"get-1\" (func 6)) + (export \"get-2\" (func 7)) + (export \"get-5\" (func 8)) + (export \"get-6\" (func 9)) + (export \"set-5\" (func 10)) + (export \"set-6\" (func 11)) + (export \"as-select-first\" (func 13)) + (export \"as-select-mid\" (func 14)) + (export \"as-select-last\" (func 15)) + (export \"as-loop-first\" (func 16)) + (export \"as-loop-mid\" (func 17)) + (export \"as-loop-last\" (func 18)) + (export \"as-if-condition\" (func 19)) + (export \"as-if-then\" (func 20)) + (export \"as-if-else\" (func 21)) + (export \"as-br_if-first\" (func 22)) + (export \"as-br_if-last\" (func 23)) + (export \"as-br_table-first\" (func 24)) + (export \"as-br_table-last\" (func 25)) + (export \"as-call_indirect-first\" (func 27)) + (export \"as-call_indirect-mid\" (func 28)) + (export \"as-call_indirect-last\" (func 29)) + (export \"as-store-first\" (func 30)) + (export \"as-store-last\" (func 31)) + (export \"as-load-operand\" (func 32)) + (export \"as-memory.grow-value\" (func 33)) + (export \"as-call-value\" (func 35)) + (export \"as-return-value\" (func 36)) + (export \"as-drop-operand\" (func 37)) + (export \"as-br-value\" (func 38)) + (export \"as-set_local-value\" (func 39)) + (export \"as-tee_local-value\" (func 40)) + (export \"as-set_global-value\" (func 41)) + (export \"as-unary-operand\" (func 42)) + (export \"as-binary-operand\" (func 43)) + (export \"as-compare-operand\" (func 44)) + (elem (;0;) (i32.const 0) 26)) + "; + 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 182 +fn c1_l182_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l182_action_invoke"); + let result = instance.call("get-a", &[]); + assert_eq!(result, Ok(Some(Value::I32(-2 as i32)))); + result.map(|_| ()) +} + +// Line 183 +fn c2_l183_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l183_action_invoke"); + let result = instance.call("get-b", &[]); + assert_eq!(result, Ok(Some(Value::I64(-5 as i64)))); + result.map(|_| ()) +} + +// Line 184 +fn c3_l184_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l184_action_invoke"); + let result = instance.call("get-x", &[]); + assert_eq!(result, Ok(Some(Value::I32(-12 as i32)))); + result.map(|_| ()) +} + +// Line 185 +fn c4_l185_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l185_action_invoke"); + let result = instance.call("get-y", &[]); + assert_eq!(result, Ok(Some(Value::I64(-15 as i64)))); + result.map(|_| ()) +} + +// Line 187 +fn c5_l187_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l187_action_invoke"); + let result = instance.call("get-1", &[]); + assert_eq!(result, Ok(Some(Value::F32((-3.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 188 +fn c6_l188_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l188_action_invoke"); + let result = instance.call("get-2", &[]); + assert_eq!(result, Ok(Some(Value::F64((-4.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 189 +fn c7_l189_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l189_action_invoke"); + let result = instance.call("get-5", &[]); + assert_eq!(result, Ok(Some(Value::F32((-13.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 190 +fn c8_l190_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l190_action_invoke"); + let result = instance.call("get-6", &[]); + assert_eq!(result, Ok(Some(Value::F64((-14.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 192 +fn c9_l192_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l192_action_invoke"); + let result = instance.call("set-x", &[Value::I32(6 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 193 +fn c10_l193_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c10_l193_action_invoke"); + let result = instance.call("set-y", &[Value::I64(7 as i64)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 194 +fn c11_l194_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c11_l194_action_invoke"); + let result = instance.call("set-5", &[Value::F32((8.0f32).to_bits())]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 195 +fn c12_l195_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c12_l195_action_invoke"); + let result = instance.call("set-6", &[Value::F64((9.0f64).to_bits())]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 197 +fn c13_l197_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c13_l197_action_invoke"); + let result = instance.call("get-x", &[]); + assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); + result.map(|_| ()) +} + +// Line 198 +fn c14_l198_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c14_l198_action_invoke"); + let result = instance.call("get-y", &[]); + assert_eq!(result, Ok(Some(Value::I64(7 as i64)))); + result.map(|_| ()) +} + +// Line 199 +fn c15_l199_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c15_l199_action_invoke"); + let result = instance.call("get-5", &[]); + assert_eq!(result, Ok(Some(Value::F32((8.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 200 +fn c16_l200_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c16_l200_action_invoke"); + let result = instance.call("get-6", &[]); + assert_eq!(result, Ok(Some(Value::F64((9.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 202 +fn c17_l202_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c17_l202_action_invoke"); + let result = instance.call("as-select-first", &[]); + assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); + result.map(|_| ()) +} + +// Line 203 +fn c18_l203_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c18_l203_action_invoke"); + let result = instance.call("as-select-mid", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 204 +fn c19_l204_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c19_l204_action_invoke"); + let result = instance.call("as-select-last", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 206 +fn c20_l206_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c20_l206_action_invoke"); + let result = instance.call("as-loop-first", &[]); + assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); + result.map(|_| ()) +} + +// Line 207 +fn c21_l207_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c21_l207_action_invoke"); + let result = instance.call("as-loop-mid", &[]); + assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); + result.map(|_| ()) +} + +// Line 208 +fn c22_l208_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c22_l208_action_invoke"); + let result = instance.call("as-loop-last", &[]); + assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); + result.map(|_| ()) +} + +// Line 210 +fn c23_l210_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c23_l210_action_invoke"); + let result = instance.call("as-if-condition", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 211 +fn c24_l211_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c24_l211_action_invoke"); + let result = instance.call("as-if-then", &[]); + assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); + result.map(|_| ()) +} + +// Line 212 +fn c25_l212_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c25_l212_action_invoke"); + let result = instance.call("as-if-else", &[]); + assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); + result.map(|_| ()) +} + +// Line 214 +fn c26_l214_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c26_l214_action_invoke"); + let result = instance.call("as-br_if-first", &[]); + assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); + result.map(|_| ()) +} + +// Line 215 +fn c27_l215_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c27_l215_action_invoke"); + let result = instance.call("as-br_if-last", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 217 +fn c28_l217_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c28_l217_action_invoke"); + let result = instance.call("as-br_table-first", &[]); + assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); + result.map(|_| ()) +} + +// Line 218 +fn c29_l218_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c29_l218_action_invoke"); + let result = instance.call("as-br_table-last", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 220 +fn c30_l220_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c30_l220_action_invoke"); + let result = instance.call("as-call_indirect-first", &[]); + assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); + result.map(|_| ()) +} + +// Line 221 +fn c31_l221_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c31_l221_action_invoke"); + let result = instance.call("as-call_indirect-mid", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 222 +fn c32_l222_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c32_l222_action_invoke"); + let result = instance.call("as-call_indirect-last", &[]); + + result.map(|_| ()) +} + +#[test] +fn c32_l222_assert_trap() { + let mut instance = create_module_1(); + let result = c32_l222_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 224 +fn c33_l224_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c33_l224_action_invoke"); + let result = instance.call("as-store-first", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 225 +fn c34_l225_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c34_l225_action_invoke"); + let result = instance.call("as-store-last", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 226 +fn c35_l226_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c35_l226_action_invoke"); + let result = instance.call("as-load-operand", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 227 +fn c36_l227_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c36_l227_action_invoke"); + let result = instance.call("as-memory.grow-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 229 +fn c37_l229_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c37_l229_action_invoke"); + let result = instance.call("as-call-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); + result.map(|_| ()) +} + +// Line 231 +fn c38_l231_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c38_l231_action_invoke"); + let result = instance.call("as-return-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); + result.map(|_| ()) +} + +// Line 232 +fn c39_l232_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c39_l232_action_invoke"); + let result = instance.call("as-drop-operand", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 233 +fn c40_l233_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c40_l233_action_invoke"); + let result = instance.call("as-br-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); + result.map(|_| ()) +} + +// Line 235 +fn c41_l235_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c41_l235_action_invoke"); + let result = instance.call("as-set_local-value", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); + result.map(|_| ()) +} + +// Line 236 +fn c42_l236_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c42_l236_action_invoke"); + let result = instance.call("as-tee_local-value", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); + result.map(|_| ()) +} + +// Line 237 +fn c43_l237_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c43_l237_action_invoke"); + let result = instance.call("as-set_global-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); + result.map(|_| ()) +} + +// Line 239 +fn c44_l239_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c44_l239_action_invoke"); + let result = instance.call("as-unary-operand", &[]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 240 +fn c45_l240_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c45_l240_action_invoke"); + let result = instance.call("as-binary-operand", &[]); + assert_eq!(result, Ok(Some(Value::I32(36 as i32)))); + result.map(|_| ()) +} + +// Line 241 +fn c46_l241_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c46_l241_action_invoke"); + let result = instance.call("as-compare-operand", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 244 +#[test] +fn c47_l244_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 6, 9, 1, 125, 0, 67, 0, 0, 0, 0, 11, 10, 8, 1, 6, 0, 65, 1, 36, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 256 +#[test] +fn c48_l256_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 10, 1, 125, 0, 67, 0, 0, 0, 0, 140, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 261 +#[test] +fn c49_l261_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 6, 1, 125, 0, 32, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 266 +#[test] +fn c50_l266_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 10, 1, 125, 0, 67, 0, 0, 128, 63, 140, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 271 +#[test] +fn c51_l271_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 7, 1, 127, 0, 65, 0, 1, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 276 +#[test] +fn c52_l276_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 5, 1, 127, 0, 1, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 281 +#[test] +fn c53_l281_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 9, 1, 127, 0, 67, 0, 0, 0, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 286 +#[test] +fn c54_l286_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 8, 1, 127, 0, 65, 0, 65, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 291 +#[test] +fn c55_l291_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 11, 2, 127, 0, 65, 0, 11, 126, 0, 35, 1, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 297 +#[test] +fn c56_l297_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 4, 1, 127, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 302 +#[test] +fn c57_l302_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 6, 1, 127, 0, 35, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 307 +#[test] +fn c58_l307_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 11, 2, 127, 0, 35, 1, 11, 127, 0, 65, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 311 + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l182_action_invoke(&mut instance); + c2_l183_action_invoke(&mut instance); + c3_l184_action_invoke(&mut instance); + c4_l185_action_invoke(&mut instance); + c5_l187_action_invoke(&mut instance); + c6_l188_action_invoke(&mut instance); + c7_l189_action_invoke(&mut instance); + c8_l190_action_invoke(&mut instance); + c9_l192_action_invoke(&mut instance); + c10_l193_action_invoke(&mut instance); + c11_l194_action_invoke(&mut instance); + c12_l195_action_invoke(&mut instance); + c13_l197_action_invoke(&mut instance); + c14_l198_action_invoke(&mut instance); + c15_l199_action_invoke(&mut instance); + c16_l200_action_invoke(&mut instance); + c17_l202_action_invoke(&mut instance); + c18_l203_action_invoke(&mut instance); + c19_l204_action_invoke(&mut instance); + c20_l206_action_invoke(&mut instance); + c21_l207_action_invoke(&mut instance); + c22_l208_action_invoke(&mut instance); + c23_l210_action_invoke(&mut instance); + c24_l211_action_invoke(&mut instance); + c25_l212_action_invoke(&mut instance); + c26_l214_action_invoke(&mut instance); + c27_l215_action_invoke(&mut instance); + c28_l217_action_invoke(&mut instance); + c29_l218_action_invoke(&mut instance); + c30_l220_action_invoke(&mut instance); + c31_l221_action_invoke(&mut instance); + c33_l224_action_invoke(&mut instance); + c34_l225_action_invoke(&mut instance); + c35_l226_action_invoke(&mut instance); + c36_l227_action_invoke(&mut instance); + c37_l229_action_invoke(&mut instance); + c38_l231_action_invoke(&mut instance); + c39_l232_action_invoke(&mut instance); + c40_l233_action_invoke(&mut instance); + c41_l235_action_invoke(&mut instance); + c42_l236_action_invoke(&mut instance); + c43_l237_action_invoke(&mut instance); + c44_l239_action_invoke(&mut instance); + c45_l240_action_invoke(&mut instance); + c46_l241_action_invoke(&mut instance); +} +fn create_module_2() -> Box { + let module_str = "(module + (type (;0;) (func (result i32))) + (import \"spectest\" \"global_i32\" (global (;0;) i32)) + (func (;0;) (type 0) (result i32) + get_global 0) + (func (;1;) (type 0) (result i32) + get_global 1) + (global (;1;) i32 (get_global 0)) + (export \"get-0\" (func 0)) + (export \"get-0-ref\" (func 1))) + "; + 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_2(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 318 +fn c60_l318_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c60_l318_action_invoke"); + let result = instance.call("get-0", &[]); + assert_eq!(result, Ok(Some(Value::I32(666 as i32)))); + result.map(|_| ()) +} + +// Line 319 +fn c61_l319_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c61_l319_action_invoke"); + let result = instance.call("get-0-ref", &[]); + assert_eq!(result, Ok(Some(Value::I32(666 as i32)))); + result.map(|_| ()) +} + +// Line 322 +#[test] +fn c62_l322_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 2, 148, 128, 128, 128, 0, 1, 8, 115, 112, 101, 99, 116, 101, 115, 116, 10, 103, 108, 111, 98, 97, 108, 95, 105, 51, 50, 3, 127, 2]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 335 +#[test] +fn c63_l335_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 2, 148, 128, 128, 128, 0, 1, 8, 115, 112, 101, 99, 116, 101, 115, 116, 10, 103, 108, 111, 98, 97, 108, 95, 105, 51, 50, 3, 127, 255]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 348 + +#[test] +fn test_module_2() { + let mut instance = create_module_2(); + // We group the calls together + start_module_2(&mut instance); + c60_l318_action_invoke(&mut instance); + c61_l319_action_invoke(&mut instance); +} +fn create_module_3() -> Box { + let module_str = "(module + (global (;0;) i32 (i32.const 0))) + "; + 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_3(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 352 +#[test] +fn c65_l352_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 134, 128, 128, 128, 0, 1, 127, 2, 65, 0, 11]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 364 +#[test] +fn c66_l364_assert_malformed() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 134, 128, 128, 128, 0, 1, 127, 255, 65, 0, 11]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +#[test] +fn test_module_3() { + let mut instance = create_module_3(); + // We group the calls together + start_module_3(&mut instance); +} diff --git a/lib/runtime/tests/spectests/i32_.rs b/lib/runtime/tests/spectests/i32_.rs new file mode 100644 index 000000000..14c93a4c3 --- /dev/null +++ b/lib/runtime/tests/spectests/i32_.rs @@ -0,0 +1,3468 @@ +// 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/i32_.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 3 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func (param i32 i32) (result i32))) + (type (;1;) (func (param i32) (result i32))) + (func (;0;) (type 0) (param i32 i32) (result i32) + get_local 0 + get_local 1 + i32.add) + (func (;1;) (type 0) (param i32 i32) (result i32) + get_local 0 + get_local 1 + i32.sub) + (func (;2;) (type 0) (param i32 i32) (result i32) + get_local 0 + get_local 1 + i32.mul) + (func (;3;) (type 0) (param i32 i32) (result i32) + get_local 0 + get_local 1 + i32.div_s) + (func (;4;) (type 0) (param i32 i32) (result i32) + get_local 0 + get_local 1 + i32.div_u) + (func (;5;) (type 0) (param i32 i32) (result i32) + get_local 0 + get_local 1 + i32.rem_s) + (func (;6;) (type 0) (param i32 i32) (result i32) + get_local 0 + get_local 1 + i32.rem_u) + (func (;7;) (type 0) (param i32 i32) (result i32) + get_local 0 + get_local 1 + i32.and) + (func (;8;) (type 0) (param i32 i32) (result i32) + get_local 0 + get_local 1 + i32.or) + (func (;9;) (type 0) (param i32 i32) (result i32) + get_local 0 + get_local 1 + i32.xor) + (func (;10;) (type 0) (param i32 i32) (result i32) + get_local 0 + get_local 1 + i32.shl) + (func (;11;) (type 0) (param i32 i32) (result i32) + get_local 0 + get_local 1 + i32.shr_s) + (func (;12;) (type 0) (param i32 i32) (result i32) + get_local 0 + get_local 1 + i32.shr_u) + (func (;13;) (type 0) (param i32 i32) (result i32) + get_local 0 + get_local 1 + i32.rotl) + (func (;14;) (type 0) (param i32 i32) (result i32) + get_local 0 + get_local 1 + i32.rotr) + (func (;15;) (type 1) (param i32) (result i32) + get_local 0 + i32.clz) + (func (;16;) (type 1) (param i32) (result i32) + get_local 0 + i32.ctz) + (func (;17;) (type 1) (param i32) (result i32) + get_local 0 + i32.popcnt) + (func (;18;) (type 1) (param i32) (result i32) + get_local 0 + i32.eqz) + (func (;19;) (type 0) (param i32 i32) (result i32) + get_local 0 + get_local 1 + i32.eq) + (func (;20;) (type 0) (param i32 i32) (result i32) + get_local 0 + get_local 1 + i32.ne) + (func (;21;) (type 0) (param i32 i32) (result i32) + get_local 0 + get_local 1 + i32.lt_s) + (func (;22;) (type 0) (param i32 i32) (result i32) + get_local 0 + get_local 1 + i32.lt_u) + (func (;23;) (type 0) (param i32 i32) (result i32) + get_local 0 + get_local 1 + i32.le_s) + (func (;24;) (type 0) (param i32 i32) (result i32) + get_local 0 + get_local 1 + i32.le_u) + (func (;25;) (type 0) (param i32 i32) (result i32) + get_local 0 + get_local 1 + i32.gt_s) + (func (;26;) (type 0) (param i32 i32) (result i32) + get_local 0 + get_local 1 + i32.gt_u) + (func (;27;) (type 0) (param i32 i32) (result i32) + get_local 0 + get_local 1 + i32.ge_s) + (func (;28;) (type 0) (param i32 i32) (result i32) + get_local 0 + get_local 1 + i32.ge_u) + (export \"add\" (func 0)) + (export \"sub\" (func 1)) + (export \"mul\" (func 2)) + (export \"div_s\" (func 3)) + (export \"div_u\" (func 4)) + (export \"rem_s\" (func 5)) + (export \"rem_u\" (func 6)) + (export \"and\" (func 7)) + (export \"or\" (func 8)) + (export \"xor\" (func 9)) + (export \"shl\" (func 10)) + (export \"shr_s\" (func 11)) + (export \"shr_u\" (func 12)) + (export \"rotl\" (func 13)) + (export \"rotr\" (func 14)) + (export \"clz\" (func 15)) + (export \"ctz\" (func 16)) + (export \"popcnt\" (func 17)) + (export \"eqz\" (func 18)) + (export \"eq\" (func 19)) + (export \"ne\" (func 20)) + (export \"lt_s\" (func 21)) + (export \"lt_u\" (func 22)) + (export \"le_s\" (func 23)) + (export \"le_u\" (func 24)) + (export \"gt_s\" (func 25)) + (export \"gt_u\" (func 26)) + (export \"ge_s\" (func 27)) + (export \"ge_u\" (func 28))) + "; + 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 35 +fn c1_l35_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l35_action_invoke"); + let result = instance.call("add", &[Value::I32(1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 36 +fn c2_l36_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l36_action_invoke"); + let result = instance.call("add", &[Value::I32(1 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 37 +fn c3_l37_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l37_action_invoke"); + let result = instance.call("add", &[Value::I32(-1 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-2 as i32)))); + result.map(|_| ()) +} + +// Line 38 +fn c4_l38_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l38_action_invoke"); + let result = instance.call("add", &[Value::I32(-1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 39 +fn c5_l39_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l39_action_invoke"); + let result = instance.call("add", &[Value::I32(2147483647 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-2147483648 as i32)))); + result.map(|_| ()) +} + +// Line 40 +fn c6_l40_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l40_action_invoke"); + let result = instance.call("add", &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2147483647 as i32)))); + result.map(|_| ()) +} + +// Line 41 +fn c7_l41_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l41_action_invoke"); + let result = instance.call("add", &[Value::I32(-2147483648 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 42 +fn c8_l42_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l42_action_invoke"); + let result = instance.call("add", &[Value::I32(1073741823 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1073741824 as i32)))); + result.map(|_| ()) +} + +// Line 44 +fn c9_l44_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l44_action_invoke"); + let result = instance.call("sub", &[Value::I32(1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 45 +fn c10_l45_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c10_l45_action_invoke"); + let result = instance.call("sub", &[Value::I32(1 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 46 +fn c11_l46_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c11_l46_action_invoke"); + let result = instance.call("sub", &[Value::I32(-1 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 47 +fn c12_l47_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c12_l47_action_invoke"); + let result = instance.call("sub", &[Value::I32(2147483647 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-2147483648 as i32)))); + result.map(|_| ()) +} + +// Line 48 +fn c13_l48_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c13_l48_action_invoke"); + let result = instance.call("sub", &[Value::I32(-2147483648 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2147483647 as i32)))); + result.map(|_| ()) +} + +// Line 49 +fn c14_l49_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c14_l49_action_invoke"); + let result = instance.call("sub", &[Value::I32(-2147483648 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 50 +fn c15_l50_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c15_l50_action_invoke"); + let result = instance.call("sub", &[Value::I32(1073741823 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1073741824 as i32)))); + result.map(|_| ()) +} + +// Line 52 +fn c16_l52_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c16_l52_action_invoke"); + let result = instance.call("mul", &[Value::I32(1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 53 +fn c17_l53_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c17_l53_action_invoke"); + let result = instance.call("mul", &[Value::I32(1 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 54 +fn c18_l54_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c18_l54_action_invoke"); + let result = instance.call("mul", &[Value::I32(-1 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 55 +fn c19_l55_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c19_l55_action_invoke"); + let result = instance.call("mul", &[Value::I32(268435456 as i32), Value::I32(4096 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 56 +fn c20_l56_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c20_l56_action_invoke"); + let result = instance.call("mul", &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 57 +fn c21_l57_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c21_l57_action_invoke"); + let result = instance.call("mul", &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-2147483648 as i32)))); + result.map(|_| ()) +} + +// Line 58 +fn c22_l58_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c22_l58_action_invoke"); + let result = instance.call("mul", &[Value::I32(2147483647 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-2147483647 as i32)))); + result.map(|_| ()) +} + +// Line 59 +fn c23_l59_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c23_l59_action_invoke"); + let result = instance.call("mul", &[Value::I32(19088743 as i32), Value::I32(1985229328 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(898528368 as i32)))); + result.map(|_| ()) +} + +// Line 60 +fn c24_l60_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c24_l60_action_invoke"); + let result = instance.call("mul", &[Value::I32(2147483647 as i32), Value::I32(2147483647 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 62 +fn c25_l62_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c25_l62_action_invoke"); + let result = instance.call("div_s", &[Value::I32(1 as i32), Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c25_l62_assert_trap() { + let mut instance = create_module_1(); + let result = c25_l62_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 63 +fn c26_l63_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c26_l63_action_invoke"); + let result = instance.call("div_s", &[Value::I32(0 as i32), Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c26_l63_assert_trap() { + let mut instance = create_module_1(); + let result = c26_l63_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 64 +fn c27_l64_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c27_l64_action_invoke"); + let result = instance.call("div_s", &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c27_l64_assert_trap() { + let mut instance = create_module_1(); + let result = c27_l64_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 65 +fn c28_l65_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c28_l65_action_invoke"); + let result = instance.call("div_s", &[Value::I32(1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 66 +fn c29_l66_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c29_l66_action_invoke"); + let result = instance.call("div_s", &[Value::I32(0 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 67 +fn c30_l67_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c30_l67_action_invoke"); + let result = instance.call("div_s", &[Value::I32(0 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 68 +fn c31_l68_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c31_l68_action_invoke"); + let result = instance.call("div_s", &[Value::I32(-1 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 69 +fn c32_l69_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c32_l69_action_invoke"); + let result = instance.call("div_s", &[Value::I32(-2147483648 as i32), Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-1073741824 as i32)))); + result.map(|_| ()) +} + +// Line 70 +fn c33_l70_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c33_l70_action_invoke"); + let result = instance.call("div_s", &[Value::I32(-2147483647 as i32), Value::I32(1000 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-2147483 as i32)))); + result.map(|_| ()) +} + +// Line 71 +fn c34_l71_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c34_l71_action_invoke"); + let result = instance.call("div_s", &[Value::I32(5 as i32), Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 72 +fn c35_l72_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c35_l72_action_invoke"); + let result = instance.call("div_s", &[Value::I32(-5 as i32), Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-2 as i32)))); + result.map(|_| ()) +} + +// Line 73 +fn c36_l73_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c36_l73_action_invoke"); + let result = instance.call("div_s", &[Value::I32(5 as i32), Value::I32(-2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-2 as i32)))); + result.map(|_| ()) +} + +// Line 74 +fn c37_l74_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c37_l74_action_invoke"); + let result = instance.call("div_s", &[Value::I32(-5 as i32), Value::I32(-2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 75 +fn c38_l75_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c38_l75_action_invoke"); + let result = instance.call("div_s", &[Value::I32(7 as i32), Value::I32(3 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 76 +fn c39_l76_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c39_l76_action_invoke"); + let result = instance.call("div_s", &[Value::I32(-7 as i32), Value::I32(3 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-2 as i32)))); + result.map(|_| ()) +} + +// Line 77 +fn c40_l77_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c40_l77_action_invoke"); + let result = instance.call("div_s", &[Value::I32(7 as i32), Value::I32(-3 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-2 as i32)))); + result.map(|_| ()) +} + +// Line 78 +fn c41_l78_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c41_l78_action_invoke"); + let result = instance.call("div_s", &[Value::I32(-7 as i32), Value::I32(-3 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 79 +fn c42_l79_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c42_l79_action_invoke"); + let result = instance.call("div_s", &[Value::I32(11 as i32), Value::I32(5 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 80 +fn c43_l80_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c43_l80_action_invoke"); + let result = instance.call("div_s", &[Value::I32(17 as i32), Value::I32(7 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 82 +fn c44_l82_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c44_l82_action_invoke"); + let result = instance.call("div_u", &[Value::I32(1 as i32), Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c44_l82_assert_trap() { + let mut instance = create_module_1(); + let result = c44_l82_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 83 +fn c45_l83_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c45_l83_action_invoke"); + let result = instance.call("div_u", &[Value::I32(0 as i32), Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c45_l83_assert_trap() { + let mut instance = create_module_1(); + let result = c45_l83_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 84 +fn c46_l84_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c46_l84_action_invoke"); + let result = instance.call("div_u", &[Value::I32(1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 85 +fn c47_l85_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c47_l85_action_invoke"); + let result = instance.call("div_u", &[Value::I32(0 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 86 +fn c48_l86_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c48_l86_action_invoke"); + let result = instance.call("div_u", &[Value::I32(-1 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 87 +fn c49_l87_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c49_l87_action_invoke"); + let result = instance.call("div_u", &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 88 +fn c50_l88_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c50_l88_action_invoke"); + let result = instance.call("div_u", &[Value::I32(-2147483648 as i32), Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1073741824 as i32)))); + result.map(|_| ()) +} + +// Line 89 +fn c51_l89_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c51_l89_action_invoke"); + let result = instance.call("div_u", &[Value::I32(-1880092688 as i32), Value::I32(65537 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(36847 as i32)))); + result.map(|_| ()) +} + +// Line 90 +fn c52_l90_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c52_l90_action_invoke"); + let result = instance.call("div_u", &[Value::I32(-2147483647 as i32), Value::I32(1000 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2147483 as i32)))); + result.map(|_| ()) +} + +// Line 91 +fn c53_l91_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c53_l91_action_invoke"); + let result = instance.call("div_u", &[Value::I32(5 as i32), Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 92 +fn c54_l92_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c54_l92_action_invoke"); + let result = instance.call("div_u", &[Value::I32(-5 as i32), Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2147483645 as i32)))); + result.map(|_| ()) +} + +// Line 93 +fn c55_l93_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c55_l93_action_invoke"); + let result = instance.call("div_u", &[Value::I32(5 as i32), Value::I32(-2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 94 +fn c56_l94_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c56_l94_action_invoke"); + let result = instance.call("div_u", &[Value::I32(-5 as i32), Value::I32(-2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 95 +fn c57_l95_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c57_l95_action_invoke"); + let result = instance.call("div_u", &[Value::I32(7 as i32), Value::I32(3 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 96 +fn c58_l96_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c58_l96_action_invoke"); + let result = instance.call("div_u", &[Value::I32(11 as i32), Value::I32(5 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 97 +fn c59_l97_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c59_l97_action_invoke"); + let result = instance.call("div_u", &[Value::I32(17 as i32), Value::I32(7 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 99 +fn c60_l99_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c60_l99_action_invoke"); + let result = instance.call("rem_s", &[Value::I32(1 as i32), Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c60_l99_assert_trap() { + let mut instance = create_module_1(); + let result = c60_l99_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 100 +fn c61_l100_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c61_l100_action_invoke"); + let result = instance.call("rem_s", &[Value::I32(0 as i32), Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c61_l100_assert_trap() { + let mut instance = create_module_1(); + let result = c61_l100_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 101 +fn c62_l101_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c62_l101_action_invoke"); + let result = instance.call("rem_s", &[Value::I32(2147483647 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 102 +fn c63_l102_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c63_l102_action_invoke"); + let result = instance.call("rem_s", &[Value::I32(1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 103 +fn c64_l103_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c64_l103_action_invoke"); + let result = instance.call("rem_s", &[Value::I32(0 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 104 +fn c65_l104_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c65_l104_action_invoke"); + let result = instance.call("rem_s", &[Value::I32(0 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 105 +fn c66_l105_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c66_l105_action_invoke"); + let result = instance.call("rem_s", &[Value::I32(-1 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 106 +fn c67_l106_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c67_l106_action_invoke"); + let result = instance.call("rem_s", &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 107 +fn c68_l107_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c68_l107_action_invoke"); + let result = instance.call("rem_s", &[Value::I32(-2147483648 as i32), Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 108 +fn c69_l108_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c69_l108_action_invoke"); + let result = instance.call("rem_s", &[Value::I32(-2147483647 as i32), Value::I32(1000 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-647 as i32)))); + result.map(|_| ()) +} + +// Line 109 +fn c70_l109_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c70_l109_action_invoke"); + let result = instance.call("rem_s", &[Value::I32(5 as i32), Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 110 +fn c71_l110_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c71_l110_action_invoke"); + let result = instance.call("rem_s", &[Value::I32(-5 as i32), Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 111 +fn c72_l111_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c72_l111_action_invoke"); + let result = instance.call("rem_s", &[Value::I32(5 as i32), Value::I32(-2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 112 +fn c73_l112_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c73_l112_action_invoke"); + let result = instance.call("rem_s", &[Value::I32(-5 as i32), Value::I32(-2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 113 +fn c74_l113_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c74_l113_action_invoke"); + let result = instance.call("rem_s", &[Value::I32(7 as i32), Value::I32(3 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 114 +fn c75_l114_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c75_l114_action_invoke"); + let result = instance.call("rem_s", &[Value::I32(-7 as i32), Value::I32(3 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 115 +fn c76_l115_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c76_l115_action_invoke"); + let result = instance.call("rem_s", &[Value::I32(7 as i32), Value::I32(-3 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 116 +fn c77_l116_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c77_l116_action_invoke"); + let result = instance.call("rem_s", &[Value::I32(-7 as i32), Value::I32(-3 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 117 +fn c78_l117_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c78_l117_action_invoke"); + let result = instance.call("rem_s", &[Value::I32(11 as i32), Value::I32(5 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 118 +fn c79_l118_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c79_l118_action_invoke"); + let result = instance.call("rem_s", &[Value::I32(17 as i32), Value::I32(7 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 120 +fn c80_l120_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c80_l120_action_invoke"); + let result = instance.call("rem_u", &[Value::I32(1 as i32), Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c80_l120_assert_trap() { + let mut instance = create_module_1(); + let result = c80_l120_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 121 +fn c81_l121_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c81_l121_action_invoke"); + let result = instance.call("rem_u", &[Value::I32(0 as i32), Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c81_l121_assert_trap() { + let mut instance = create_module_1(); + let result = c81_l121_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 122 +fn c82_l122_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c82_l122_action_invoke"); + let result = instance.call("rem_u", &[Value::I32(1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 123 +fn c83_l123_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c83_l123_action_invoke"); + let result = instance.call("rem_u", &[Value::I32(0 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 124 +fn c84_l124_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c84_l124_action_invoke"); + let result = instance.call("rem_u", &[Value::I32(-1 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 125 +fn c85_l125_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c85_l125_action_invoke"); + let result = instance.call("rem_u", &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-2147483648 as i32)))); + result.map(|_| ()) +} + +// Line 126 +fn c86_l126_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c86_l126_action_invoke"); + let result = instance.call("rem_u", &[Value::I32(-2147483648 as i32), Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 127 +fn c87_l127_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c87_l127_action_invoke"); + let result = instance.call("rem_u", &[Value::I32(-1880092688 as i32), Value::I32(65537 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(32769 as i32)))); + result.map(|_| ()) +} + +// Line 128 +fn c88_l128_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c88_l128_action_invoke"); + let result = instance.call("rem_u", &[Value::I32(-2147483647 as i32), Value::I32(1000 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(649 as i32)))); + result.map(|_| ()) +} + +// Line 129 +fn c89_l129_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c89_l129_action_invoke"); + let result = instance.call("rem_u", &[Value::I32(5 as i32), Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 130 +fn c90_l130_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c90_l130_action_invoke"); + let result = instance.call("rem_u", &[Value::I32(-5 as i32), Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 131 +fn c91_l131_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c91_l131_action_invoke"); + let result = instance.call("rem_u", &[Value::I32(5 as i32), Value::I32(-2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(5 as i32)))); + result.map(|_| ()) +} + +// Line 132 +fn c92_l132_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c92_l132_action_invoke"); + let result = instance.call("rem_u", &[Value::I32(-5 as i32), Value::I32(-2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-5 as i32)))); + result.map(|_| ()) +} + +// Line 133 +fn c93_l133_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c93_l133_action_invoke"); + let result = instance.call("rem_u", &[Value::I32(7 as i32), Value::I32(3 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 134 +fn c94_l134_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c94_l134_action_invoke"); + let result = instance.call("rem_u", &[Value::I32(11 as i32), Value::I32(5 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 135 +fn c95_l135_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c95_l135_action_invoke"); + let result = instance.call("rem_u", &[Value::I32(17 as i32), Value::I32(7 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 137 +fn c96_l137_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c96_l137_action_invoke"); + let result = instance.call("and", &[Value::I32(1 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 138 +fn c97_l138_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c97_l138_action_invoke"); + let result = instance.call("and", &[Value::I32(0 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 139 +fn c98_l139_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c98_l139_action_invoke"); + let result = instance.call("and", &[Value::I32(1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 140 +fn c99_l140_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c99_l140_action_invoke"); + let result = instance.call("and", &[Value::I32(0 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 141 +fn c100_l141_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c100_l141_action_invoke"); + let result = instance.call("and", &[Value::I32(2147483647 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 142 +fn c101_l142_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c101_l142_action_invoke"); + let result = instance.call("and", &[Value::I32(2147483647 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2147483647 as i32)))); + result.map(|_| ()) +} + +// Line 143 +fn c102_l143_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c102_l143_action_invoke"); + let result = instance.call("and", &[Value::I32(-252641281 as i32), Value::I32(-3856 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-252645136 as i32)))); + result.map(|_| ()) +} + +// Line 144 +fn c103_l144_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c103_l144_action_invoke"); + let result = instance.call("and", &[Value::I32(-1 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 146 +fn c104_l146_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c104_l146_action_invoke"); + let result = instance.call("or", &[Value::I32(1 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 147 +fn c105_l147_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c105_l147_action_invoke"); + let result = instance.call("or", &[Value::I32(0 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 148 +fn c106_l148_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c106_l148_action_invoke"); + let result = instance.call("or", &[Value::I32(1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 149 +fn c107_l149_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c107_l149_action_invoke"); + let result = instance.call("or", &[Value::I32(0 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 150 +fn c108_l150_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c108_l150_action_invoke"); + let result = instance.call("or", &[Value::I32(2147483647 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 151 +fn c109_l151_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c109_l151_action_invoke"); + let result = instance.call("or", &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-2147483648 as i32)))); + result.map(|_| ()) +} + +// Line 152 +fn c110_l152_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c110_l152_action_invoke"); + let result = instance.call("or", &[Value::I32(-252641281 as i32), Value::I32(-3856 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 153 +fn c111_l153_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c111_l153_action_invoke"); + let result = instance.call("or", &[Value::I32(-1 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 155 +fn c112_l155_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c112_l155_action_invoke"); + let result = instance.call("xor", &[Value::I32(1 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 156 +fn c113_l156_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c113_l156_action_invoke"); + let result = instance.call("xor", &[Value::I32(0 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 157 +fn c114_l157_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c114_l157_action_invoke"); + let result = instance.call("xor", &[Value::I32(1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 158 +fn c115_l158_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c115_l158_action_invoke"); + let result = instance.call("xor", &[Value::I32(0 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 159 +fn c116_l159_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c116_l159_action_invoke"); + let result = instance.call("xor", &[Value::I32(2147483647 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 160 +fn c117_l160_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c117_l160_action_invoke"); + let result = instance.call("xor", &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-2147483648 as i32)))); + result.map(|_| ()) +} + +// Line 161 +fn c118_l161_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c118_l161_action_invoke"); + let result = instance.call("xor", &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2147483647 as i32)))); + result.map(|_| ()) +} + +// Line 162 +fn c119_l162_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c119_l162_action_invoke"); + let result = instance.call("xor", &[Value::I32(-1 as i32), Value::I32(2147483647 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-2147483648 as i32)))); + result.map(|_| ()) +} + +// Line 163 +fn c120_l163_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c120_l163_action_invoke"); + let result = instance.call("xor", &[Value::I32(-252641281 as i32), Value::I32(-3856 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(252645135 as i32)))); + result.map(|_| ()) +} + +// Line 164 +fn c121_l164_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c121_l164_action_invoke"); + let result = instance.call("xor", &[Value::I32(-1 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 166 +fn c122_l166_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c122_l166_action_invoke"); + let result = instance.call("shl", &[Value::I32(1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 167 +fn c123_l167_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c123_l167_action_invoke"); + let result = instance.call("shl", &[Value::I32(1 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 168 +fn c124_l168_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c124_l168_action_invoke"); + let result = instance.call("shl", &[Value::I32(2147483647 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-2 as i32)))); + result.map(|_| ()) +} + +// Line 169 +fn c125_l169_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c125_l169_action_invoke"); + let result = instance.call("shl", &[Value::I32(-1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-2 as i32)))); + result.map(|_| ()) +} + +// Line 170 +fn c126_l170_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c126_l170_action_invoke"); + let result = instance.call("shl", &[Value::I32(-2147483648 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 171 +fn c127_l171_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c127_l171_action_invoke"); + let result = instance.call("shl", &[Value::I32(1073741824 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-2147483648 as i32)))); + result.map(|_| ()) +} + +// Line 172 +fn c128_l172_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c128_l172_action_invoke"); + let result = instance.call("shl", &[Value::I32(1 as i32), Value::I32(31 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-2147483648 as i32)))); + result.map(|_| ()) +} + +// Line 173 +fn c129_l173_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c129_l173_action_invoke"); + let result = instance.call("shl", &[Value::I32(1 as i32), Value::I32(32 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 174 +fn c130_l174_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c130_l174_action_invoke"); + let result = instance.call("shl", &[Value::I32(1 as i32), Value::I32(33 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 175 +fn c131_l175_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c131_l175_action_invoke"); + let result = instance.call("shl", &[Value::I32(1 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-2147483648 as i32)))); + result.map(|_| ()) +} + +// Line 176 +fn c132_l176_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c132_l176_action_invoke"); + let result = instance.call("shl", &[Value::I32(1 as i32), Value::I32(2147483647 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-2147483648 as i32)))); + result.map(|_| ()) +} + +// Line 178 +fn c133_l178_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c133_l178_action_invoke"); + let result = instance.call("shr_s", &[Value::I32(1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 179 +fn c134_l179_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c134_l179_action_invoke"); + let result = instance.call("shr_s", &[Value::I32(1 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 180 +fn c135_l180_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c135_l180_action_invoke"); + let result = instance.call("shr_s", &[Value::I32(-1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 181 +fn c136_l181_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c136_l181_action_invoke"); + let result = instance.call("shr_s", &[Value::I32(2147483647 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1073741823 as i32)))); + result.map(|_| ()) +} + +// Line 182 +fn c137_l182_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c137_l182_action_invoke"); + let result = instance.call("shr_s", &[Value::I32(-2147483648 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-1073741824 as i32)))); + result.map(|_| ()) +} + +// Line 183 +fn c138_l183_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c138_l183_action_invoke"); + let result = instance.call("shr_s", &[Value::I32(1073741824 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(536870912 as i32)))); + result.map(|_| ()) +} + +// Line 184 +fn c139_l184_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c139_l184_action_invoke"); + let result = instance.call("shr_s", &[Value::I32(1 as i32), Value::I32(32 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 185 +fn c140_l185_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c140_l185_action_invoke"); + let result = instance.call("shr_s", &[Value::I32(1 as i32), Value::I32(33 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 186 +fn c141_l186_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c141_l186_action_invoke"); + let result = instance.call("shr_s", &[Value::I32(1 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 187 +fn c142_l187_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c142_l187_action_invoke"); + let result = instance.call("shr_s", &[Value::I32(1 as i32), Value::I32(2147483647 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 188 +fn c143_l188_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c143_l188_action_invoke"); + let result = instance.call("shr_s", &[Value::I32(1 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 189 +fn c144_l189_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c144_l189_action_invoke"); + let result = instance.call("shr_s", &[Value::I32(-2147483648 as i32), Value::I32(31 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 190 +fn c145_l190_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c145_l190_action_invoke"); + let result = instance.call("shr_s", &[Value::I32(-1 as i32), Value::I32(32 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 191 +fn c146_l191_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c146_l191_action_invoke"); + let result = instance.call("shr_s", &[Value::I32(-1 as i32), Value::I32(33 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 192 +fn c147_l192_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c147_l192_action_invoke"); + let result = instance.call("shr_s", &[Value::I32(-1 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 193 +fn c148_l193_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c148_l193_action_invoke"); + let result = instance.call("shr_s", &[Value::I32(-1 as i32), Value::I32(2147483647 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 194 +fn c149_l194_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c149_l194_action_invoke"); + let result = instance.call("shr_s", &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 196 +fn c150_l196_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c150_l196_action_invoke"); + let result = instance.call("shr_u", &[Value::I32(1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 197 +fn c151_l197_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c151_l197_action_invoke"); + let result = instance.call("shr_u", &[Value::I32(1 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 198 +fn c152_l198_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c152_l198_action_invoke"); + let result = instance.call("shr_u", &[Value::I32(-1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2147483647 as i32)))); + result.map(|_| ()) +} + +// Line 199 +fn c153_l199_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c153_l199_action_invoke"); + let result = instance.call("shr_u", &[Value::I32(2147483647 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1073741823 as i32)))); + result.map(|_| ()) +} + +// Line 200 +fn c154_l200_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c154_l200_action_invoke"); + let result = instance.call("shr_u", &[Value::I32(-2147483648 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1073741824 as i32)))); + result.map(|_| ()) +} + +// Line 201 +fn c155_l201_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c155_l201_action_invoke"); + let result = instance.call("shr_u", &[Value::I32(1073741824 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(536870912 as i32)))); + result.map(|_| ()) +} + +// Line 202 +fn c156_l202_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c156_l202_action_invoke"); + let result = instance.call("shr_u", &[Value::I32(1 as i32), Value::I32(32 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 203 +fn c157_l203_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c157_l203_action_invoke"); + let result = instance.call("shr_u", &[Value::I32(1 as i32), Value::I32(33 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 204 +fn c158_l204_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c158_l204_action_invoke"); + let result = instance.call("shr_u", &[Value::I32(1 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 205 +fn c159_l205_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c159_l205_action_invoke"); + let result = instance.call("shr_u", &[Value::I32(1 as i32), Value::I32(2147483647 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 206 +fn c160_l206_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c160_l206_action_invoke"); + let result = instance.call("shr_u", &[Value::I32(1 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 207 +fn c161_l207_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c161_l207_action_invoke"); + let result = instance.call("shr_u", &[Value::I32(-2147483648 as i32), Value::I32(31 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 208 +fn c162_l208_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c162_l208_action_invoke"); + let result = instance.call("shr_u", &[Value::I32(-1 as i32), Value::I32(32 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 209 +fn c163_l209_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c163_l209_action_invoke"); + let result = instance.call("shr_u", &[Value::I32(-1 as i32), Value::I32(33 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2147483647 as i32)))); + result.map(|_| ()) +} + +// Line 210 +fn c164_l210_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c164_l210_action_invoke"); + let result = instance.call("shr_u", &[Value::I32(-1 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 211 +fn c165_l211_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c165_l211_action_invoke"); + let result = instance.call("shr_u", &[Value::I32(-1 as i32), Value::I32(2147483647 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 212 +fn c166_l212_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c166_l212_action_invoke"); + let result = instance.call("shr_u", &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 214 +fn c167_l214_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c167_l214_action_invoke"); + let result = instance.call("rotl", &[Value::I32(1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 215 +fn c168_l215_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c168_l215_action_invoke"); + let result = instance.call("rotl", &[Value::I32(1 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 216 +fn c169_l216_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c169_l216_action_invoke"); + let result = instance.call("rotl", &[Value::I32(-1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 217 +fn c170_l217_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c170_l217_action_invoke"); + let result = instance.call("rotl", &[Value::I32(1 as i32), Value::I32(32 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 218 +fn c171_l218_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c171_l218_action_invoke"); + let result = instance.call("rotl", &[Value::I32(-1412589450 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1469788397 as i32)))); + result.map(|_| ()) +} + +// Line 219 +fn c172_l219_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c172_l219_action_invoke"); + let result = instance.call("rotl", &[Value::I32(-33498112 as i32), Value::I32(4 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-535969777 as i32)))); + result.map(|_| ()) +} + +// Line 220 +fn c173_l220_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c173_l220_action_invoke"); + let result = instance.call("rotl", &[Value::I32(-1329474845 as i32), Value::I32(5 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(406477942 as i32)))); + result.map(|_| ()) +} + +// Line 221 +fn c174_l221_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c174_l221_action_invoke"); + let result = instance.call("rotl", &[Value::I32(32768 as i32), Value::I32(37 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1048576 as i32)))); + result.map(|_| ()) +} + +// Line 222 +fn c175_l222_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c175_l222_action_invoke"); + let result = instance.call("rotl", &[Value::I32(-1329474845 as i32), Value::I32(65285 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(406477942 as i32)))); + result.map(|_| ()) +} + +// Line 223 +fn c176_l223_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c176_l223_action_invoke"); + let result = instance.call("rotl", &[Value::I32(1989852383 as i32), Value::I32(-19 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1469837011 as i32)))); + result.map(|_| ()) +} + +// Line 224 +fn c177_l224_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c177_l224_action_invoke"); + let result = instance.call("rotl", &[Value::I32(1989852383 as i32), Value::I32(-2147483635 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1469837011 as i32)))); + result.map(|_| ()) +} + +// Line 225 +fn c178_l225_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c178_l225_action_invoke"); + let result = instance.call("rotl", &[Value::I32(1 as i32), Value::I32(31 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-2147483648 as i32)))); + result.map(|_| ()) +} + +// Line 226 +fn c179_l226_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c179_l226_action_invoke"); + let result = instance.call("rotl", &[Value::I32(-2147483648 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 228 +fn c180_l228_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c180_l228_action_invoke"); + let result = instance.call("rotr", &[Value::I32(1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-2147483648 as i32)))); + result.map(|_| ()) +} + +// Line 229 +fn c181_l229_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c181_l229_action_invoke"); + let result = instance.call("rotr", &[Value::I32(1 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 230 +fn c182_l230_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c182_l230_action_invoke"); + let result = instance.call("rotr", &[Value::I32(-1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 231 +fn c183_l231_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c183_l231_action_invoke"); + let result = instance.call("rotr", &[Value::I32(1 as i32), Value::I32(32 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 232 +fn c184_l232_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c184_l232_action_invoke"); + let result = instance.call("rotr", &[Value::I32(-16724992 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2139121152 as i32)))); + result.map(|_| ()) +} + +// Line 233 +fn c185_l233_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c185_l233_action_invoke"); + let result = instance.call("rotr", &[Value::I32(524288 as i32), Value::I32(4 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(32768 as i32)))); + result.map(|_| ()) +} + +// Line 234 +fn c186_l234_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c186_l234_action_invoke"); + let result = instance.call("rotr", &[Value::I32(-1329474845 as i32), Value::I32(5 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(495324823 as i32)))); + result.map(|_| ()) +} + +// Line 235 +fn c187_l235_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c187_l235_action_invoke"); + let result = instance.call("rotr", &[Value::I32(32768 as i32), Value::I32(37 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1024 as i32)))); + result.map(|_| ()) +} + +// Line 236 +fn c188_l236_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c188_l236_action_invoke"); + let result = instance.call("rotr", &[Value::I32(-1329474845 as i32), Value::I32(65285 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(495324823 as i32)))); + result.map(|_| ()) +} + +// Line 237 +fn c189_l237_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c189_l237_action_invoke"); + let result = instance.call("rotr", &[Value::I32(1989852383 as i32), Value::I32(-19 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-419711787 as i32)))); + result.map(|_| ()) +} + +// Line 238 +fn c190_l238_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c190_l238_action_invoke"); + let result = instance.call("rotr", &[Value::I32(1989852383 as i32), Value::I32(-2147483635 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-419711787 as i32)))); + result.map(|_| ()) +} + +// Line 239 +fn c191_l239_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c191_l239_action_invoke"); + let result = instance.call("rotr", &[Value::I32(1 as i32), Value::I32(31 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 240 +fn c192_l240_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c192_l240_action_invoke"); + let result = instance.call("rotr", &[Value::I32(-2147483648 as i32), Value::I32(31 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 242 +fn c193_l242_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c193_l242_action_invoke"); + let result = instance.call("clz", &[Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 243 +fn c194_l243_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c194_l243_action_invoke"); + let result = instance.call("clz", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(32 as i32)))); + result.map(|_| ()) +} + +// Line 244 +fn c195_l244_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c195_l244_action_invoke"); + let result = instance.call("clz", &[Value::I32(32768 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(16 as i32)))); + result.map(|_| ()) +} + +// Line 245 +fn c196_l245_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c196_l245_action_invoke"); + let result = instance.call("clz", &[Value::I32(255 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(24 as i32)))); + result.map(|_| ()) +} + +// Line 246 +fn c197_l246_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c197_l246_action_invoke"); + let result = instance.call("clz", &[Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 247 +fn c198_l247_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c198_l247_action_invoke"); + let result = instance.call("clz", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(31 as i32)))); + result.map(|_| ()) +} + +// Line 248 +fn c199_l248_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c199_l248_action_invoke"); + let result = instance.call("clz", &[Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(30 as i32)))); + result.map(|_| ()) +} + +// Line 249 +fn c200_l249_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c200_l249_action_invoke"); + let result = instance.call("clz", &[Value::I32(2147483647 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 251 +fn c201_l251_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c201_l251_action_invoke"); + let result = instance.call("ctz", &[Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 252 +fn c202_l252_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c202_l252_action_invoke"); + let result = instance.call("ctz", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(32 as i32)))); + result.map(|_| ()) +} + +// Line 253 +fn c203_l253_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c203_l253_action_invoke"); + let result = instance.call("ctz", &[Value::I32(32768 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(15 as i32)))); + result.map(|_| ()) +} + +// Line 254 +fn c204_l254_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c204_l254_action_invoke"); + let result = instance.call("ctz", &[Value::I32(65536 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(16 as i32)))); + result.map(|_| ()) +} + +// Line 255 +fn c205_l255_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c205_l255_action_invoke"); + let result = instance.call("ctz", &[Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(31 as i32)))); + result.map(|_| ()) +} + +// Line 256 +fn c206_l256_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c206_l256_action_invoke"); + let result = instance.call("ctz", &[Value::I32(2147483647 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 258 +fn c207_l258_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c207_l258_action_invoke"); + let result = instance.call("popcnt", &[Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(32 as i32)))); + result.map(|_| ()) +} + +// Line 259 +fn c208_l259_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c208_l259_action_invoke"); + let result = instance.call("popcnt", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 260 +fn c209_l260_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c209_l260_action_invoke"); + let result = instance.call("popcnt", &[Value::I32(32768 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 261 +fn c210_l261_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c210_l261_action_invoke"); + let result = instance.call("popcnt", &[Value::I32(-2147450880 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 262 +fn c211_l262_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c211_l262_action_invoke"); + let result = instance.call("popcnt", &[Value::I32(2147483647 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(31 as i32)))); + result.map(|_| ()) +} + +// Line 263 +fn c212_l263_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c212_l263_action_invoke"); + let result = instance.call("popcnt", &[Value::I32(-1431655766 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(16 as i32)))); + result.map(|_| ()) +} + +// Line 264 +fn c213_l264_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c213_l264_action_invoke"); + let result = instance.call("popcnt", &[Value::I32(1431655765 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(16 as i32)))); + result.map(|_| ()) +} + +// Line 265 +fn c214_l265_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c214_l265_action_invoke"); + let result = instance.call("popcnt", &[Value::I32(-559038737 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(24 as i32)))); + result.map(|_| ()) +} + +// Line 267 +fn c215_l267_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c215_l267_action_invoke"); + let result = instance.call("eqz", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 268 +fn c216_l268_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c216_l268_action_invoke"); + let result = instance.call("eqz", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 269 +fn c217_l269_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c217_l269_action_invoke"); + let result = instance.call("eqz", &[Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 270 +fn c218_l270_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c218_l270_action_invoke"); + let result = instance.call("eqz", &[Value::I32(2147483647 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 271 +fn c219_l271_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c219_l271_action_invoke"); + let result = instance.call("eqz", &[Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 273 +fn c220_l273_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c220_l273_action_invoke"); + let result = instance.call("eq", &[Value::I32(0 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 274 +fn c221_l274_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c221_l274_action_invoke"); + let result = instance.call("eq", &[Value::I32(1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 275 +fn c222_l275_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c222_l275_action_invoke"); + let result = instance.call("eq", &[Value::I32(-1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 276 +fn c223_l276_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c223_l276_action_invoke"); + let result = instance.call("eq", &[Value::I32(-2147483648 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 277 +fn c224_l277_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c224_l277_action_invoke"); + let result = instance.call("eq", &[Value::I32(2147483647 as i32), Value::I32(2147483647 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 278 +fn c225_l278_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c225_l278_action_invoke"); + let result = instance.call("eq", &[Value::I32(-1 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 279 +fn c226_l279_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c226_l279_action_invoke"); + let result = instance.call("eq", &[Value::I32(1 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 280 +fn c227_l280_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c227_l280_action_invoke"); + let result = instance.call("eq", &[Value::I32(0 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 281 +fn c228_l281_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c228_l281_action_invoke"); + let result = instance.call("eq", &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 282 +fn c229_l282_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c229_l282_action_invoke"); + let result = instance.call("eq", &[Value::I32(0 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 283 +fn c230_l283_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c230_l283_action_invoke"); + let result = instance.call("eq", &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 284 +fn c231_l284_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c231_l284_action_invoke"); + let result = instance.call("eq", &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 285 +fn c232_l285_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c232_l285_action_invoke"); + let result = instance.call("eq", &[Value::I32(-2147483648 as i32), Value::I32(2147483647 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 286 +fn c233_l286_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c233_l286_action_invoke"); + let result = instance.call("eq", &[Value::I32(2147483647 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 288 +fn c234_l288_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c234_l288_action_invoke"); + let result = instance.call("ne", &[Value::I32(0 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 289 +fn c235_l289_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c235_l289_action_invoke"); + let result = instance.call("ne", &[Value::I32(1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 290 +fn c236_l290_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c236_l290_action_invoke"); + let result = instance.call("ne", &[Value::I32(-1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 291 +fn c237_l291_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c237_l291_action_invoke"); + let result = instance.call("ne", &[Value::I32(-2147483648 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 292 +fn c238_l292_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c238_l292_action_invoke"); + let result = instance.call("ne", &[Value::I32(2147483647 as i32), Value::I32(2147483647 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 293 +fn c239_l293_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c239_l293_action_invoke"); + let result = instance.call("ne", &[Value::I32(-1 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 294 +fn c240_l294_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c240_l294_action_invoke"); + let result = instance.call("ne", &[Value::I32(1 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 295 +fn c241_l295_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c241_l295_action_invoke"); + let result = instance.call("ne", &[Value::I32(0 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 296 +fn c242_l296_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c242_l296_action_invoke"); + let result = instance.call("ne", &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 297 +fn c243_l297_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c243_l297_action_invoke"); + let result = instance.call("ne", &[Value::I32(0 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 298 +fn c244_l298_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c244_l298_action_invoke"); + let result = instance.call("ne", &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 299 +fn c245_l299_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c245_l299_action_invoke"); + let result = instance.call("ne", &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 300 +fn c246_l300_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c246_l300_action_invoke"); + let result = instance.call("ne", &[Value::I32(-2147483648 as i32), Value::I32(2147483647 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 301 +fn c247_l301_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c247_l301_action_invoke"); + let result = instance.call("ne", &[Value::I32(2147483647 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 303 +fn c248_l303_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c248_l303_action_invoke"); + let result = instance.call("lt_s", &[Value::I32(0 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 304 +fn c249_l304_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c249_l304_action_invoke"); + let result = instance.call("lt_s", &[Value::I32(1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 305 +fn c250_l305_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c250_l305_action_invoke"); + let result = instance.call("lt_s", &[Value::I32(-1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 306 +fn c251_l306_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c251_l306_action_invoke"); + let result = instance.call("lt_s", &[Value::I32(-2147483648 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 307 +fn c252_l307_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c252_l307_action_invoke"); + let result = instance.call("lt_s", &[Value::I32(2147483647 as i32), Value::I32(2147483647 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 308 +fn c253_l308_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c253_l308_action_invoke"); + let result = instance.call("lt_s", &[Value::I32(-1 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 309 +fn c254_l309_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c254_l309_action_invoke"); + let result = instance.call("lt_s", &[Value::I32(1 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 310 +fn c255_l310_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c255_l310_action_invoke"); + let result = instance.call("lt_s", &[Value::I32(0 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 311 +fn c256_l311_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c256_l311_action_invoke"); + let result = instance.call("lt_s", &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 312 +fn c257_l312_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c257_l312_action_invoke"); + let result = instance.call("lt_s", &[Value::I32(0 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 313 +fn c258_l313_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c258_l313_action_invoke"); + let result = instance.call("lt_s", &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 314 +fn c259_l314_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c259_l314_action_invoke"); + let result = instance.call("lt_s", &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 315 +fn c260_l315_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c260_l315_action_invoke"); + let result = instance.call("lt_s", &[Value::I32(-2147483648 as i32), Value::I32(2147483647 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 316 +fn c261_l316_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c261_l316_action_invoke"); + let result = instance.call("lt_s", &[Value::I32(2147483647 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 318 +fn c262_l318_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c262_l318_action_invoke"); + let result = instance.call("lt_u", &[Value::I32(0 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 319 +fn c263_l319_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c263_l319_action_invoke"); + let result = instance.call("lt_u", &[Value::I32(1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 320 +fn c264_l320_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c264_l320_action_invoke"); + let result = instance.call("lt_u", &[Value::I32(-1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 321 +fn c265_l321_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c265_l321_action_invoke"); + let result = instance.call("lt_u", &[Value::I32(-2147483648 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 322 +fn c266_l322_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c266_l322_action_invoke"); + let result = instance.call("lt_u", &[Value::I32(2147483647 as i32), Value::I32(2147483647 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 323 +fn c267_l323_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c267_l323_action_invoke"); + let result = instance.call("lt_u", &[Value::I32(-1 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 324 +fn c268_l324_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c268_l324_action_invoke"); + let result = instance.call("lt_u", &[Value::I32(1 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 325 +fn c269_l325_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c269_l325_action_invoke"); + let result = instance.call("lt_u", &[Value::I32(0 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 326 +fn c270_l326_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c270_l326_action_invoke"); + let result = instance.call("lt_u", &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 327 +fn c271_l327_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c271_l327_action_invoke"); + let result = instance.call("lt_u", &[Value::I32(0 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 328 +fn c272_l328_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c272_l328_action_invoke"); + let result = instance.call("lt_u", &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 329 +fn c273_l329_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c273_l329_action_invoke"); + let result = instance.call("lt_u", &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 330 +fn c274_l330_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c274_l330_action_invoke"); + let result = instance.call("lt_u", &[Value::I32(-2147483648 as i32), Value::I32(2147483647 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 331 +fn c275_l331_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c275_l331_action_invoke"); + let result = instance.call("lt_u", &[Value::I32(2147483647 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 333 +fn c276_l333_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c276_l333_action_invoke"); + let result = instance.call("le_s", &[Value::I32(0 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 334 +fn c277_l334_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c277_l334_action_invoke"); + let result = instance.call("le_s", &[Value::I32(1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 335 +fn c278_l335_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c278_l335_action_invoke"); + let result = instance.call("le_s", &[Value::I32(-1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 336 +fn c279_l336_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c279_l336_action_invoke"); + let result = instance.call("le_s", &[Value::I32(-2147483648 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 337 +fn c280_l337_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c280_l337_action_invoke"); + let result = instance.call("le_s", &[Value::I32(2147483647 as i32), Value::I32(2147483647 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 338 +fn c281_l338_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c281_l338_action_invoke"); + let result = instance.call("le_s", &[Value::I32(-1 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 339 +fn c282_l339_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c282_l339_action_invoke"); + let result = instance.call("le_s", &[Value::I32(1 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 340 +fn c283_l340_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c283_l340_action_invoke"); + let result = instance.call("le_s", &[Value::I32(0 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 341 +fn c284_l341_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c284_l341_action_invoke"); + let result = instance.call("le_s", &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 342 +fn c285_l342_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c285_l342_action_invoke"); + let result = instance.call("le_s", &[Value::I32(0 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 343 +fn c286_l343_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c286_l343_action_invoke"); + let result = instance.call("le_s", &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 344 +fn c287_l344_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c287_l344_action_invoke"); + let result = instance.call("le_s", &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 345 +fn c288_l345_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c288_l345_action_invoke"); + let result = instance.call("le_s", &[Value::I32(-2147483648 as i32), Value::I32(2147483647 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 346 +fn c289_l346_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c289_l346_action_invoke"); + let result = instance.call("le_s", &[Value::I32(2147483647 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 348 +fn c290_l348_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c290_l348_action_invoke"); + let result = instance.call("le_u", &[Value::I32(0 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 349 +fn c291_l349_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c291_l349_action_invoke"); + let result = instance.call("le_u", &[Value::I32(1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 350 +fn c292_l350_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c292_l350_action_invoke"); + let result = instance.call("le_u", &[Value::I32(-1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 351 +fn c293_l351_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c293_l351_action_invoke"); + let result = instance.call("le_u", &[Value::I32(-2147483648 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 352 +fn c294_l352_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c294_l352_action_invoke"); + let result = instance.call("le_u", &[Value::I32(2147483647 as i32), Value::I32(2147483647 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 353 +fn c295_l353_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c295_l353_action_invoke"); + let result = instance.call("le_u", &[Value::I32(-1 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 354 +fn c296_l354_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c296_l354_action_invoke"); + let result = instance.call("le_u", &[Value::I32(1 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 355 +fn c297_l355_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c297_l355_action_invoke"); + let result = instance.call("le_u", &[Value::I32(0 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 356 +fn c298_l356_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c298_l356_action_invoke"); + let result = instance.call("le_u", &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 357 +fn c299_l357_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c299_l357_action_invoke"); + let result = instance.call("le_u", &[Value::I32(0 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 358 +fn c300_l358_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c300_l358_action_invoke"); + let result = instance.call("le_u", &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 359 +fn c301_l359_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c301_l359_action_invoke"); + let result = instance.call("le_u", &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 360 +fn c302_l360_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c302_l360_action_invoke"); + let result = instance.call("le_u", &[Value::I32(-2147483648 as i32), Value::I32(2147483647 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 361 +fn c303_l361_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c303_l361_action_invoke"); + let result = instance.call("le_u", &[Value::I32(2147483647 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 363 +fn c304_l363_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c304_l363_action_invoke"); + let result = instance.call("gt_s", &[Value::I32(0 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 364 +fn c305_l364_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c305_l364_action_invoke"); + let result = instance.call("gt_s", &[Value::I32(1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 365 +fn c306_l365_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c306_l365_action_invoke"); + let result = instance.call("gt_s", &[Value::I32(-1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 366 +fn c307_l366_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c307_l366_action_invoke"); + let result = instance.call("gt_s", &[Value::I32(-2147483648 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 367 +fn c308_l367_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c308_l367_action_invoke"); + let result = instance.call("gt_s", &[Value::I32(2147483647 as i32), Value::I32(2147483647 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 368 +fn c309_l368_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c309_l368_action_invoke"); + let result = instance.call("gt_s", &[Value::I32(-1 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 369 +fn c310_l369_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c310_l369_action_invoke"); + let result = instance.call("gt_s", &[Value::I32(1 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 370 +fn c311_l370_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c311_l370_action_invoke"); + let result = instance.call("gt_s", &[Value::I32(0 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 371 +fn c312_l371_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c312_l371_action_invoke"); + let result = instance.call("gt_s", &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 372 +fn c313_l372_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c313_l372_action_invoke"); + let result = instance.call("gt_s", &[Value::I32(0 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 373 +fn c314_l373_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c314_l373_action_invoke"); + let result = instance.call("gt_s", &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 374 +fn c315_l374_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c315_l374_action_invoke"); + let result = instance.call("gt_s", &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 375 +fn c316_l375_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c316_l375_action_invoke"); + let result = instance.call("gt_s", &[Value::I32(-2147483648 as i32), Value::I32(2147483647 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 376 +fn c317_l376_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c317_l376_action_invoke"); + let result = instance.call("gt_s", &[Value::I32(2147483647 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 378 +fn c318_l378_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c318_l378_action_invoke"); + let result = instance.call("gt_u", &[Value::I32(0 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 379 +fn c319_l379_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c319_l379_action_invoke"); + let result = instance.call("gt_u", &[Value::I32(1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 380 +fn c320_l380_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c320_l380_action_invoke"); + let result = instance.call("gt_u", &[Value::I32(-1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 381 +fn c321_l381_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c321_l381_action_invoke"); + let result = instance.call("gt_u", &[Value::I32(-2147483648 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 382 +fn c322_l382_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c322_l382_action_invoke"); + let result = instance.call("gt_u", &[Value::I32(2147483647 as i32), Value::I32(2147483647 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 383 +fn c323_l383_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c323_l383_action_invoke"); + let result = instance.call("gt_u", &[Value::I32(-1 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 384 +fn c324_l384_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c324_l384_action_invoke"); + let result = instance.call("gt_u", &[Value::I32(1 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 385 +fn c325_l385_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c325_l385_action_invoke"); + let result = instance.call("gt_u", &[Value::I32(0 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 386 +fn c326_l386_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c326_l386_action_invoke"); + let result = instance.call("gt_u", &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 387 +fn c327_l387_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c327_l387_action_invoke"); + let result = instance.call("gt_u", &[Value::I32(0 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 388 +fn c328_l388_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c328_l388_action_invoke"); + let result = instance.call("gt_u", &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 389 +fn c329_l389_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c329_l389_action_invoke"); + let result = instance.call("gt_u", &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 390 +fn c330_l390_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c330_l390_action_invoke"); + let result = instance.call("gt_u", &[Value::I32(-2147483648 as i32), Value::I32(2147483647 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 391 +fn c331_l391_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c331_l391_action_invoke"); + let result = instance.call("gt_u", &[Value::I32(2147483647 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 393 +fn c332_l393_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c332_l393_action_invoke"); + let result = instance.call("ge_s", &[Value::I32(0 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 394 +fn c333_l394_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c333_l394_action_invoke"); + let result = instance.call("ge_s", &[Value::I32(1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 395 +fn c334_l395_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c334_l395_action_invoke"); + let result = instance.call("ge_s", &[Value::I32(-1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 396 +fn c335_l396_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c335_l396_action_invoke"); + let result = instance.call("ge_s", &[Value::I32(-2147483648 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 397 +fn c336_l397_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c336_l397_action_invoke"); + let result = instance.call("ge_s", &[Value::I32(2147483647 as i32), Value::I32(2147483647 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 398 +fn c337_l398_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c337_l398_action_invoke"); + let result = instance.call("ge_s", &[Value::I32(-1 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 399 +fn c338_l399_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c338_l399_action_invoke"); + let result = instance.call("ge_s", &[Value::I32(1 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 400 +fn c339_l400_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c339_l400_action_invoke"); + let result = instance.call("ge_s", &[Value::I32(0 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 401 +fn c340_l401_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c340_l401_action_invoke"); + let result = instance.call("ge_s", &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 402 +fn c341_l402_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c341_l402_action_invoke"); + let result = instance.call("ge_s", &[Value::I32(0 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 403 +fn c342_l403_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c342_l403_action_invoke"); + let result = instance.call("ge_s", &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 404 +fn c343_l404_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c343_l404_action_invoke"); + let result = instance.call("ge_s", &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 405 +fn c344_l405_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c344_l405_action_invoke"); + let result = instance.call("ge_s", &[Value::I32(-2147483648 as i32), Value::I32(2147483647 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 406 +fn c345_l406_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c345_l406_action_invoke"); + let result = instance.call("ge_s", &[Value::I32(2147483647 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 408 +fn c346_l408_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c346_l408_action_invoke"); + let result = instance.call("ge_u", &[Value::I32(0 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 409 +fn c347_l409_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c347_l409_action_invoke"); + let result = instance.call("ge_u", &[Value::I32(1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 410 +fn c348_l410_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c348_l410_action_invoke"); + let result = instance.call("ge_u", &[Value::I32(-1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 411 +fn c349_l411_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c349_l411_action_invoke"); + let result = instance.call("ge_u", &[Value::I32(-2147483648 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 412 +fn c350_l412_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c350_l412_action_invoke"); + let result = instance.call("ge_u", &[Value::I32(2147483647 as i32), Value::I32(2147483647 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 413 +fn c351_l413_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c351_l413_action_invoke"); + let result = instance.call("ge_u", &[Value::I32(-1 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 414 +fn c352_l414_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c352_l414_action_invoke"); + let result = instance.call("ge_u", &[Value::I32(1 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 415 +fn c353_l415_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c353_l415_action_invoke"); + let result = instance.call("ge_u", &[Value::I32(0 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 416 +fn c354_l416_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c354_l416_action_invoke"); + let result = instance.call("ge_u", &[Value::I32(-2147483648 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 417 +fn c355_l417_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c355_l417_action_invoke"); + let result = instance.call("ge_u", &[Value::I32(0 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 418 +fn c356_l418_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c356_l418_action_invoke"); + let result = instance.call("ge_u", &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 419 +fn c357_l419_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c357_l419_action_invoke"); + let result = instance.call("ge_u", &[Value::I32(-1 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 420 +fn c358_l420_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c358_l420_action_invoke"); + let result = instance.call("ge_u", &[Value::I32(-2147483648 as i32), Value::I32(2147483647 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 421 +fn c359_l421_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c359_l421_action_invoke"); + let result = instance.call("ge_u", &[Value::I32(2147483647 as i32), Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l35_action_invoke(&mut instance); + c2_l36_action_invoke(&mut instance); + c3_l37_action_invoke(&mut instance); + c4_l38_action_invoke(&mut instance); + c5_l39_action_invoke(&mut instance); + c6_l40_action_invoke(&mut instance); + c7_l41_action_invoke(&mut instance); + c8_l42_action_invoke(&mut instance); + c9_l44_action_invoke(&mut instance); + c10_l45_action_invoke(&mut instance); + c11_l46_action_invoke(&mut instance); + c12_l47_action_invoke(&mut instance); + c13_l48_action_invoke(&mut instance); + c14_l49_action_invoke(&mut instance); + c15_l50_action_invoke(&mut instance); + c16_l52_action_invoke(&mut instance); + c17_l53_action_invoke(&mut instance); + c18_l54_action_invoke(&mut instance); + c19_l55_action_invoke(&mut instance); + c20_l56_action_invoke(&mut instance); + c21_l57_action_invoke(&mut instance); + c22_l58_action_invoke(&mut instance); + c23_l59_action_invoke(&mut instance); + c24_l60_action_invoke(&mut instance); + c28_l65_action_invoke(&mut instance); + c29_l66_action_invoke(&mut instance); + c30_l67_action_invoke(&mut instance); + c31_l68_action_invoke(&mut instance); + c32_l69_action_invoke(&mut instance); + c33_l70_action_invoke(&mut instance); + c34_l71_action_invoke(&mut instance); + c35_l72_action_invoke(&mut instance); + c36_l73_action_invoke(&mut instance); + c37_l74_action_invoke(&mut instance); + c38_l75_action_invoke(&mut instance); + c39_l76_action_invoke(&mut instance); + c40_l77_action_invoke(&mut instance); + c41_l78_action_invoke(&mut instance); + c42_l79_action_invoke(&mut instance); + c43_l80_action_invoke(&mut instance); + c46_l84_action_invoke(&mut instance); + c47_l85_action_invoke(&mut instance); + c48_l86_action_invoke(&mut instance); + c49_l87_action_invoke(&mut instance); + c50_l88_action_invoke(&mut instance); + c51_l89_action_invoke(&mut instance); + c52_l90_action_invoke(&mut instance); + c53_l91_action_invoke(&mut instance); + c54_l92_action_invoke(&mut instance); + c55_l93_action_invoke(&mut instance); + c56_l94_action_invoke(&mut instance); + c57_l95_action_invoke(&mut instance); + c58_l96_action_invoke(&mut instance); + c59_l97_action_invoke(&mut instance); + c62_l101_action_invoke(&mut instance); + c63_l102_action_invoke(&mut instance); + c64_l103_action_invoke(&mut instance); + c65_l104_action_invoke(&mut instance); + c66_l105_action_invoke(&mut instance); + c67_l106_action_invoke(&mut instance); + c68_l107_action_invoke(&mut instance); + c69_l108_action_invoke(&mut instance); + c70_l109_action_invoke(&mut instance); + c71_l110_action_invoke(&mut instance); + c72_l111_action_invoke(&mut instance); + c73_l112_action_invoke(&mut instance); + c74_l113_action_invoke(&mut instance); + c75_l114_action_invoke(&mut instance); + c76_l115_action_invoke(&mut instance); + c77_l116_action_invoke(&mut instance); + c78_l117_action_invoke(&mut instance); + c79_l118_action_invoke(&mut instance); + c82_l122_action_invoke(&mut instance); + c83_l123_action_invoke(&mut instance); + c84_l124_action_invoke(&mut instance); + c85_l125_action_invoke(&mut instance); + c86_l126_action_invoke(&mut instance); + c87_l127_action_invoke(&mut instance); + c88_l128_action_invoke(&mut instance); + c89_l129_action_invoke(&mut instance); + c90_l130_action_invoke(&mut instance); + c91_l131_action_invoke(&mut instance); + c92_l132_action_invoke(&mut instance); + c93_l133_action_invoke(&mut instance); + c94_l134_action_invoke(&mut instance); + c95_l135_action_invoke(&mut instance); + c96_l137_action_invoke(&mut instance); + c97_l138_action_invoke(&mut instance); + c98_l139_action_invoke(&mut instance); + c99_l140_action_invoke(&mut instance); + c100_l141_action_invoke(&mut instance); + c101_l142_action_invoke(&mut instance); + c102_l143_action_invoke(&mut instance); + c103_l144_action_invoke(&mut instance); + c104_l146_action_invoke(&mut instance); + c105_l147_action_invoke(&mut instance); + c106_l148_action_invoke(&mut instance); + c107_l149_action_invoke(&mut instance); + c108_l150_action_invoke(&mut instance); + c109_l151_action_invoke(&mut instance); + c110_l152_action_invoke(&mut instance); + c111_l153_action_invoke(&mut instance); + c112_l155_action_invoke(&mut instance); + c113_l156_action_invoke(&mut instance); + c114_l157_action_invoke(&mut instance); + c115_l158_action_invoke(&mut instance); + c116_l159_action_invoke(&mut instance); + c117_l160_action_invoke(&mut instance); + c118_l161_action_invoke(&mut instance); + c119_l162_action_invoke(&mut instance); + c120_l163_action_invoke(&mut instance); + c121_l164_action_invoke(&mut instance); + c122_l166_action_invoke(&mut instance); + c123_l167_action_invoke(&mut instance); + c124_l168_action_invoke(&mut instance); + c125_l169_action_invoke(&mut instance); + c126_l170_action_invoke(&mut instance); + c127_l171_action_invoke(&mut instance); + c128_l172_action_invoke(&mut instance); + c129_l173_action_invoke(&mut instance); + c130_l174_action_invoke(&mut instance); + c131_l175_action_invoke(&mut instance); + c132_l176_action_invoke(&mut instance); + c133_l178_action_invoke(&mut instance); + c134_l179_action_invoke(&mut instance); + c135_l180_action_invoke(&mut instance); + c136_l181_action_invoke(&mut instance); + c137_l182_action_invoke(&mut instance); + c138_l183_action_invoke(&mut instance); + c139_l184_action_invoke(&mut instance); + c140_l185_action_invoke(&mut instance); + c141_l186_action_invoke(&mut instance); + c142_l187_action_invoke(&mut instance); + c143_l188_action_invoke(&mut instance); + c144_l189_action_invoke(&mut instance); + c145_l190_action_invoke(&mut instance); + c146_l191_action_invoke(&mut instance); + c147_l192_action_invoke(&mut instance); + c148_l193_action_invoke(&mut instance); + c149_l194_action_invoke(&mut instance); + c150_l196_action_invoke(&mut instance); + c151_l197_action_invoke(&mut instance); + c152_l198_action_invoke(&mut instance); + c153_l199_action_invoke(&mut instance); + c154_l200_action_invoke(&mut instance); + c155_l201_action_invoke(&mut instance); + c156_l202_action_invoke(&mut instance); + c157_l203_action_invoke(&mut instance); + c158_l204_action_invoke(&mut instance); + c159_l205_action_invoke(&mut instance); + c160_l206_action_invoke(&mut instance); + c161_l207_action_invoke(&mut instance); + c162_l208_action_invoke(&mut instance); + c163_l209_action_invoke(&mut instance); + c164_l210_action_invoke(&mut instance); + c165_l211_action_invoke(&mut instance); + c166_l212_action_invoke(&mut instance); + c167_l214_action_invoke(&mut instance); + c168_l215_action_invoke(&mut instance); + c169_l216_action_invoke(&mut instance); + c170_l217_action_invoke(&mut instance); + c171_l218_action_invoke(&mut instance); + c172_l219_action_invoke(&mut instance); + c173_l220_action_invoke(&mut instance); + c174_l221_action_invoke(&mut instance); + c175_l222_action_invoke(&mut instance); + c176_l223_action_invoke(&mut instance); + c177_l224_action_invoke(&mut instance); + c178_l225_action_invoke(&mut instance); + c179_l226_action_invoke(&mut instance); + c180_l228_action_invoke(&mut instance); + c181_l229_action_invoke(&mut instance); + c182_l230_action_invoke(&mut instance); + c183_l231_action_invoke(&mut instance); + c184_l232_action_invoke(&mut instance); + c185_l233_action_invoke(&mut instance); + c186_l234_action_invoke(&mut instance); + c187_l235_action_invoke(&mut instance); + c188_l236_action_invoke(&mut instance); + c189_l237_action_invoke(&mut instance); + c190_l238_action_invoke(&mut instance); + c191_l239_action_invoke(&mut instance); + c192_l240_action_invoke(&mut instance); + c193_l242_action_invoke(&mut instance); + c194_l243_action_invoke(&mut instance); + c195_l244_action_invoke(&mut instance); + c196_l245_action_invoke(&mut instance); + c197_l246_action_invoke(&mut instance); + c198_l247_action_invoke(&mut instance); + c199_l248_action_invoke(&mut instance); + c200_l249_action_invoke(&mut instance); + c201_l251_action_invoke(&mut instance); + c202_l252_action_invoke(&mut instance); + c203_l253_action_invoke(&mut instance); + c204_l254_action_invoke(&mut instance); + c205_l255_action_invoke(&mut instance); + c206_l256_action_invoke(&mut instance); + c207_l258_action_invoke(&mut instance); + c208_l259_action_invoke(&mut instance); + c209_l260_action_invoke(&mut instance); + c210_l261_action_invoke(&mut instance); + c211_l262_action_invoke(&mut instance); + c212_l263_action_invoke(&mut instance); + c213_l264_action_invoke(&mut instance); + c214_l265_action_invoke(&mut instance); + c215_l267_action_invoke(&mut instance); + c216_l268_action_invoke(&mut instance); + c217_l269_action_invoke(&mut instance); + c218_l270_action_invoke(&mut instance); + c219_l271_action_invoke(&mut instance); + c220_l273_action_invoke(&mut instance); + c221_l274_action_invoke(&mut instance); + c222_l275_action_invoke(&mut instance); + c223_l276_action_invoke(&mut instance); + c224_l277_action_invoke(&mut instance); + c225_l278_action_invoke(&mut instance); + c226_l279_action_invoke(&mut instance); + c227_l280_action_invoke(&mut instance); + c228_l281_action_invoke(&mut instance); + c229_l282_action_invoke(&mut instance); + c230_l283_action_invoke(&mut instance); + c231_l284_action_invoke(&mut instance); + c232_l285_action_invoke(&mut instance); + c233_l286_action_invoke(&mut instance); + c234_l288_action_invoke(&mut instance); + c235_l289_action_invoke(&mut instance); + c236_l290_action_invoke(&mut instance); + c237_l291_action_invoke(&mut instance); + c238_l292_action_invoke(&mut instance); + c239_l293_action_invoke(&mut instance); + c240_l294_action_invoke(&mut instance); + c241_l295_action_invoke(&mut instance); + c242_l296_action_invoke(&mut instance); + c243_l297_action_invoke(&mut instance); + c244_l298_action_invoke(&mut instance); + c245_l299_action_invoke(&mut instance); + c246_l300_action_invoke(&mut instance); + c247_l301_action_invoke(&mut instance); + c248_l303_action_invoke(&mut instance); + c249_l304_action_invoke(&mut instance); + c250_l305_action_invoke(&mut instance); + c251_l306_action_invoke(&mut instance); + c252_l307_action_invoke(&mut instance); + c253_l308_action_invoke(&mut instance); + c254_l309_action_invoke(&mut instance); + c255_l310_action_invoke(&mut instance); + c256_l311_action_invoke(&mut instance); + c257_l312_action_invoke(&mut instance); + c258_l313_action_invoke(&mut instance); + c259_l314_action_invoke(&mut instance); + c260_l315_action_invoke(&mut instance); + c261_l316_action_invoke(&mut instance); + c262_l318_action_invoke(&mut instance); + c263_l319_action_invoke(&mut instance); + c264_l320_action_invoke(&mut instance); + c265_l321_action_invoke(&mut instance); + c266_l322_action_invoke(&mut instance); + c267_l323_action_invoke(&mut instance); + c268_l324_action_invoke(&mut instance); + c269_l325_action_invoke(&mut instance); + c270_l326_action_invoke(&mut instance); + c271_l327_action_invoke(&mut instance); + c272_l328_action_invoke(&mut instance); + c273_l329_action_invoke(&mut instance); + c274_l330_action_invoke(&mut instance); + c275_l331_action_invoke(&mut instance); + c276_l333_action_invoke(&mut instance); + c277_l334_action_invoke(&mut instance); + c278_l335_action_invoke(&mut instance); + c279_l336_action_invoke(&mut instance); + c280_l337_action_invoke(&mut instance); + c281_l338_action_invoke(&mut instance); + c282_l339_action_invoke(&mut instance); + c283_l340_action_invoke(&mut instance); + c284_l341_action_invoke(&mut instance); + c285_l342_action_invoke(&mut instance); + c286_l343_action_invoke(&mut instance); + c287_l344_action_invoke(&mut instance); + c288_l345_action_invoke(&mut instance); + c289_l346_action_invoke(&mut instance); + c290_l348_action_invoke(&mut instance); + c291_l349_action_invoke(&mut instance); + c292_l350_action_invoke(&mut instance); + c293_l351_action_invoke(&mut instance); + c294_l352_action_invoke(&mut instance); + c295_l353_action_invoke(&mut instance); + c296_l354_action_invoke(&mut instance); + c297_l355_action_invoke(&mut instance); + c298_l356_action_invoke(&mut instance); + c299_l357_action_invoke(&mut instance); + c300_l358_action_invoke(&mut instance); + c301_l359_action_invoke(&mut instance); + c302_l360_action_invoke(&mut instance); + c303_l361_action_invoke(&mut instance); + c304_l363_action_invoke(&mut instance); + c305_l364_action_invoke(&mut instance); + c306_l365_action_invoke(&mut instance); + c307_l366_action_invoke(&mut instance); + c308_l367_action_invoke(&mut instance); + c309_l368_action_invoke(&mut instance); + c310_l369_action_invoke(&mut instance); + c311_l370_action_invoke(&mut instance); + c312_l371_action_invoke(&mut instance); + c313_l372_action_invoke(&mut instance); + c314_l373_action_invoke(&mut instance); + c315_l374_action_invoke(&mut instance); + c316_l375_action_invoke(&mut instance); + c317_l376_action_invoke(&mut instance); + c318_l378_action_invoke(&mut instance); + c319_l379_action_invoke(&mut instance); + c320_l380_action_invoke(&mut instance); + c321_l381_action_invoke(&mut instance); + c322_l382_action_invoke(&mut instance); + c323_l383_action_invoke(&mut instance); + c324_l384_action_invoke(&mut instance); + c325_l385_action_invoke(&mut instance); + c326_l386_action_invoke(&mut instance); + c327_l387_action_invoke(&mut instance); + c328_l388_action_invoke(&mut instance); + c329_l389_action_invoke(&mut instance); + c330_l390_action_invoke(&mut instance); + c331_l391_action_invoke(&mut instance); + c332_l393_action_invoke(&mut instance); + c333_l394_action_invoke(&mut instance); + c334_l395_action_invoke(&mut instance); + c335_l396_action_invoke(&mut instance); + c336_l397_action_invoke(&mut instance); + c337_l398_action_invoke(&mut instance); + c338_l399_action_invoke(&mut instance); + c339_l400_action_invoke(&mut instance); + c340_l401_action_invoke(&mut instance); + c341_l402_action_invoke(&mut instance); + c342_l403_action_invoke(&mut instance); + c343_l404_action_invoke(&mut instance); + c344_l405_action_invoke(&mut instance); + c345_l406_action_invoke(&mut instance); + c346_l408_action_invoke(&mut instance); + c347_l409_action_invoke(&mut instance); + c348_l410_action_invoke(&mut instance); + c349_l411_action_invoke(&mut instance); + c350_l412_action_invoke(&mut instance); + c351_l413_action_invoke(&mut instance); + c352_l414_action_invoke(&mut instance); + c353_l415_action_invoke(&mut instance); + c354_l416_action_invoke(&mut instance); + c355_l417_action_invoke(&mut instance); + c356_l418_action_invoke(&mut instance); + c357_l419_action_invoke(&mut instance); + c358_l420_action_invoke(&mut instance); + c359_l421_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/i64_.rs b/lib/runtime/tests/spectests/i64_.rs new file mode 100644 index 000000000..4ae5dfa43 --- /dev/null +++ b/lib/runtime/tests/spectests/i64_.rs @@ -0,0 +1,3470 @@ +// 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/i64_.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 3 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func (param i64 i64) (result i64))) + (type (;1;) (func (param i64) (result i64))) + (type (;2;) (func (param i64) (result i32))) + (type (;3;) (func (param i64 i64) (result i32))) + (func (;0;) (type 0) (param i64 i64) (result i64) + get_local 0 + get_local 1 + i64.add) + (func (;1;) (type 0) (param i64 i64) (result i64) + get_local 0 + get_local 1 + i64.sub) + (func (;2;) (type 0) (param i64 i64) (result i64) + get_local 0 + get_local 1 + i64.mul) + (func (;3;) (type 0) (param i64 i64) (result i64) + get_local 0 + get_local 1 + i64.div_s) + (func (;4;) (type 0) (param i64 i64) (result i64) + get_local 0 + get_local 1 + i64.div_u) + (func (;5;) (type 0) (param i64 i64) (result i64) + get_local 0 + get_local 1 + i64.rem_s) + (func (;6;) (type 0) (param i64 i64) (result i64) + get_local 0 + get_local 1 + i64.rem_u) + (func (;7;) (type 0) (param i64 i64) (result i64) + get_local 0 + get_local 1 + i64.and) + (func (;8;) (type 0) (param i64 i64) (result i64) + get_local 0 + get_local 1 + i64.or) + (func (;9;) (type 0) (param i64 i64) (result i64) + get_local 0 + get_local 1 + i64.xor) + (func (;10;) (type 0) (param i64 i64) (result i64) + get_local 0 + get_local 1 + i64.shl) + (func (;11;) (type 0) (param i64 i64) (result i64) + get_local 0 + get_local 1 + i64.shr_s) + (func (;12;) (type 0) (param i64 i64) (result i64) + get_local 0 + get_local 1 + i64.shr_u) + (func (;13;) (type 0) (param i64 i64) (result i64) + get_local 0 + get_local 1 + i64.rotl) + (func (;14;) (type 0) (param i64 i64) (result i64) + get_local 0 + get_local 1 + i64.rotr) + (func (;15;) (type 1) (param i64) (result i64) + get_local 0 + i64.clz) + (func (;16;) (type 1) (param i64) (result i64) + get_local 0 + i64.ctz) + (func (;17;) (type 1) (param i64) (result i64) + get_local 0 + i64.popcnt) + (func (;18;) (type 2) (param i64) (result i32) + get_local 0 + i64.eqz) + (func (;19;) (type 3) (param i64 i64) (result i32) + get_local 0 + get_local 1 + i64.eq) + (func (;20;) (type 3) (param i64 i64) (result i32) + get_local 0 + get_local 1 + i64.ne) + (func (;21;) (type 3) (param i64 i64) (result i32) + get_local 0 + get_local 1 + i64.lt_s) + (func (;22;) (type 3) (param i64 i64) (result i32) + get_local 0 + get_local 1 + i64.lt_u) + (func (;23;) (type 3) (param i64 i64) (result i32) + get_local 0 + get_local 1 + i64.le_s) + (func (;24;) (type 3) (param i64 i64) (result i32) + get_local 0 + get_local 1 + i64.le_u) + (func (;25;) (type 3) (param i64 i64) (result i32) + get_local 0 + get_local 1 + i64.gt_s) + (func (;26;) (type 3) (param i64 i64) (result i32) + get_local 0 + get_local 1 + i64.gt_u) + (func (;27;) (type 3) (param i64 i64) (result i32) + get_local 0 + get_local 1 + i64.ge_s) + (func (;28;) (type 3) (param i64 i64) (result i32) + get_local 0 + get_local 1 + i64.ge_u) + (export \"add\" (func 0)) + (export \"sub\" (func 1)) + (export \"mul\" (func 2)) + (export \"div_s\" (func 3)) + (export \"div_u\" (func 4)) + (export \"rem_s\" (func 5)) + (export \"rem_u\" (func 6)) + (export \"and\" (func 7)) + (export \"or\" (func 8)) + (export \"xor\" (func 9)) + (export \"shl\" (func 10)) + (export \"shr_s\" (func 11)) + (export \"shr_u\" (func 12)) + (export \"rotl\" (func 13)) + (export \"rotr\" (func 14)) + (export \"clz\" (func 15)) + (export \"ctz\" (func 16)) + (export \"popcnt\" (func 17)) + (export \"eqz\" (func 18)) + (export \"eq\" (func 19)) + (export \"ne\" (func 20)) + (export \"lt_s\" (func 21)) + (export \"lt_u\" (func 22)) + (export \"le_s\" (func 23)) + (export \"le_u\" (func 24)) + (export \"gt_s\" (func 25)) + (export \"gt_u\" (func 26)) + (export \"ge_s\" (func 27)) + (export \"ge_u\" (func 28))) + "; + 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 35 +fn c1_l35_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l35_action_invoke"); + let result = instance.call("add", &[Value::I64(1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(2 as i64)))); + result.map(|_| ()) +} + +// Line 36 +fn c2_l36_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l36_action_invoke"); + let result = instance.call("add", &[Value::I64(1 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 37 +fn c3_l37_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l37_action_invoke"); + let result = instance.call("add", &[Value::I64(-1 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-2 as i64)))); + result.map(|_| ()) +} + +// Line 38 +fn c4_l38_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l38_action_invoke"); + let result = instance.call("add", &[Value::I64(-1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 39 +fn c5_l39_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l39_action_invoke"); + let result = instance.call("add", &[Value::I64(9223372036854775807 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-9223372036854775808 as i64)))); + result.map(|_| ()) +} + +// Line 40 +fn c6_l40_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l40_action_invoke"); + let result = instance.call("add", &[Value::I64(-9223372036854775808 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(9223372036854775807 as i64)))); + result.map(|_| ()) +} + +// Line 41 +fn c7_l41_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l41_action_invoke"); + let result = instance.call("add", &[Value::I64(-9223372036854775808 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 42 +fn c8_l42_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l42_action_invoke"); + let result = instance.call("add", &[Value::I64(1073741823 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1073741824 as i64)))); + result.map(|_| ()) +} + +// Line 44 +fn c9_l44_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l44_action_invoke"); + let result = instance.call("sub", &[Value::I64(1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 45 +fn c10_l45_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c10_l45_action_invoke"); + let result = instance.call("sub", &[Value::I64(1 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 46 +fn c11_l46_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c11_l46_action_invoke"); + let result = instance.call("sub", &[Value::I64(-1 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 47 +fn c12_l47_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c12_l47_action_invoke"); + let result = instance.call("sub", &[Value::I64(9223372036854775807 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-9223372036854775808 as i64)))); + result.map(|_| ()) +} + +// Line 48 +fn c13_l48_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c13_l48_action_invoke"); + let result = instance.call("sub", &[Value::I64(-9223372036854775808 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(9223372036854775807 as i64)))); + result.map(|_| ()) +} + +// Line 49 +fn c14_l49_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c14_l49_action_invoke"); + let result = instance.call("sub", &[Value::I64(-9223372036854775808 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 50 +fn c15_l50_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c15_l50_action_invoke"); + let result = instance.call("sub", &[Value::I64(1073741823 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1073741824 as i64)))); + result.map(|_| ()) +} + +// Line 52 +fn c16_l52_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c16_l52_action_invoke"); + let result = instance.call("mul", &[Value::I64(1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 53 +fn c17_l53_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c17_l53_action_invoke"); + let result = instance.call("mul", &[Value::I64(1 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 54 +fn c18_l54_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c18_l54_action_invoke"); + let result = instance.call("mul", &[Value::I64(-1 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 55 +fn c19_l55_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c19_l55_action_invoke"); + let result = instance.call("mul", &[Value::I64(1152921504606846976 as i64), Value::I64(4096 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 56 +fn c20_l56_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c20_l56_action_invoke"); + let result = instance.call("mul", &[Value::I64(-9223372036854775808 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 57 +fn c21_l57_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c21_l57_action_invoke"); + let result = instance.call("mul", &[Value::I64(-9223372036854775808 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-9223372036854775808 as i64)))); + result.map(|_| ()) +} + +// Line 58 +fn c22_l58_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c22_l58_action_invoke"); + let result = instance.call("mul", &[Value::I64(9223372036854775807 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-9223372036854775807 as i64)))); + result.map(|_| ()) +} + +// Line 59 +fn c23_l59_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c23_l59_action_invoke"); + let result = instance.call("mul", &[Value::I64(81985529216486895 as i64), Value::I64(-81985529216486896 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(2465395958572223728 as i64)))); + result.map(|_| ()) +} + +// Line 60 +fn c24_l60_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c24_l60_action_invoke"); + let result = instance.call("mul", &[Value::I64(9223372036854775807 as i64), Value::I64(9223372036854775807 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 62 +fn c25_l62_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c25_l62_action_invoke"); + let result = instance.call("div_s", &[Value::I64(1 as i64), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c25_l62_assert_trap() { + let mut instance = create_module_1(); + let result = c25_l62_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 63 +fn c26_l63_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c26_l63_action_invoke"); + let result = instance.call("div_s", &[Value::I64(0 as i64), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c26_l63_assert_trap() { + let mut instance = create_module_1(); + let result = c26_l63_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 64 +fn c27_l64_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c27_l64_action_invoke"); + let result = instance.call("div_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(-1 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c27_l64_assert_trap() { + let mut instance = create_module_1(); + let result = c27_l64_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 65 +fn c28_l65_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c28_l65_action_invoke"); + let result = instance.call("div_s", &[Value::I64(1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 66 +fn c29_l66_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c29_l66_action_invoke"); + let result = instance.call("div_s", &[Value::I64(0 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 67 +fn c30_l67_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c30_l67_action_invoke"); + let result = instance.call("div_s", &[Value::I64(0 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 68 +fn c31_l68_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c31_l68_action_invoke"); + let result = instance.call("div_s", &[Value::I64(-1 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 69 +fn c32_l69_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c32_l69_action_invoke"); + let result = instance.call("div_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(2 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-4611686018427387904 as i64)))); + result.map(|_| ()) +} + +// Line 70 +fn c33_l70_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c33_l70_action_invoke"); + let result = instance.call("div_s", &[Value::I64(-9223372036854775807 as i64), Value::I64(1000 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-9223372036854775 as i64)))); + result.map(|_| ()) +} + +// Line 71 +fn c34_l71_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c34_l71_action_invoke"); + let result = instance.call("div_s", &[Value::I64(5 as i64), Value::I64(2 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(2 as i64)))); + result.map(|_| ()) +} + +// Line 72 +fn c35_l72_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c35_l72_action_invoke"); + let result = instance.call("div_s", &[Value::I64(-5 as i64), Value::I64(2 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-2 as i64)))); + result.map(|_| ()) +} + +// Line 73 +fn c36_l73_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c36_l73_action_invoke"); + let result = instance.call("div_s", &[Value::I64(5 as i64), Value::I64(-2 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-2 as i64)))); + result.map(|_| ()) +} + +// Line 74 +fn c37_l74_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c37_l74_action_invoke"); + let result = instance.call("div_s", &[Value::I64(-5 as i64), Value::I64(-2 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(2 as i64)))); + result.map(|_| ()) +} + +// Line 75 +fn c38_l75_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c38_l75_action_invoke"); + let result = instance.call("div_s", &[Value::I64(7 as i64), Value::I64(3 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(2 as i64)))); + result.map(|_| ()) +} + +// Line 76 +fn c39_l76_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c39_l76_action_invoke"); + let result = instance.call("div_s", &[Value::I64(-7 as i64), Value::I64(3 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-2 as i64)))); + result.map(|_| ()) +} + +// Line 77 +fn c40_l77_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c40_l77_action_invoke"); + let result = instance.call("div_s", &[Value::I64(7 as i64), Value::I64(-3 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-2 as i64)))); + result.map(|_| ()) +} + +// Line 78 +fn c41_l78_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c41_l78_action_invoke"); + let result = instance.call("div_s", &[Value::I64(-7 as i64), Value::I64(-3 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(2 as i64)))); + result.map(|_| ()) +} + +// Line 79 +fn c42_l79_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c42_l79_action_invoke"); + let result = instance.call("div_s", &[Value::I64(11 as i64), Value::I64(5 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(2 as i64)))); + result.map(|_| ()) +} + +// Line 80 +fn c43_l80_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c43_l80_action_invoke"); + let result = instance.call("div_s", &[Value::I64(17 as i64), Value::I64(7 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(2 as i64)))); + result.map(|_| ()) +} + +// Line 82 +fn c44_l82_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c44_l82_action_invoke"); + let result = instance.call("div_u", &[Value::I64(1 as i64), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c44_l82_assert_trap() { + let mut instance = create_module_1(); + let result = c44_l82_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 83 +fn c45_l83_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c45_l83_action_invoke"); + let result = instance.call("div_u", &[Value::I64(0 as i64), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c45_l83_assert_trap() { + let mut instance = create_module_1(); + let result = c45_l83_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 84 +fn c46_l84_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c46_l84_action_invoke"); + let result = instance.call("div_u", &[Value::I64(1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 85 +fn c47_l85_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c47_l85_action_invoke"); + let result = instance.call("div_u", &[Value::I64(0 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 86 +fn c48_l86_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c48_l86_action_invoke"); + let result = instance.call("div_u", &[Value::I64(-1 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 87 +fn c49_l87_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c49_l87_action_invoke"); + let result = instance.call("div_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 88 +fn c50_l88_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c50_l88_action_invoke"); + let result = instance.call("div_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(2 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(4611686018427387904 as i64)))); + result.map(|_| ()) +} + +// Line 89 +fn c51_l89_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c51_l89_action_invoke"); + let result = instance.call("div_u", &[Value::I64(-8074936608141340688 as i64), Value::I64(4294967297 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(2414874607 as i64)))); + result.map(|_| ()) +} + +// Line 90 +fn c52_l90_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c52_l90_action_invoke"); + let result = instance.call("div_u", &[Value::I64(-9223372036854775807 as i64), Value::I64(1000 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(9223372036854775 as i64)))); + result.map(|_| ()) +} + +// Line 91 +fn c53_l91_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c53_l91_action_invoke"); + let result = instance.call("div_u", &[Value::I64(5 as i64), Value::I64(2 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(2 as i64)))); + result.map(|_| ()) +} + +// Line 92 +fn c54_l92_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c54_l92_action_invoke"); + let result = instance.call("div_u", &[Value::I64(-5 as i64), Value::I64(2 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(9223372036854775805 as i64)))); + result.map(|_| ()) +} + +// Line 93 +fn c55_l93_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c55_l93_action_invoke"); + let result = instance.call("div_u", &[Value::I64(5 as i64), Value::I64(-2 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 94 +fn c56_l94_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c56_l94_action_invoke"); + let result = instance.call("div_u", &[Value::I64(-5 as i64), Value::I64(-2 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 95 +fn c57_l95_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c57_l95_action_invoke"); + let result = instance.call("div_u", &[Value::I64(7 as i64), Value::I64(3 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(2 as i64)))); + result.map(|_| ()) +} + +// Line 96 +fn c58_l96_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c58_l96_action_invoke"); + let result = instance.call("div_u", &[Value::I64(11 as i64), Value::I64(5 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(2 as i64)))); + result.map(|_| ()) +} + +// Line 97 +fn c59_l97_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c59_l97_action_invoke"); + let result = instance.call("div_u", &[Value::I64(17 as i64), Value::I64(7 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(2 as i64)))); + result.map(|_| ()) +} + +// Line 99 +fn c60_l99_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c60_l99_action_invoke"); + let result = instance.call("rem_s", &[Value::I64(1 as i64), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c60_l99_assert_trap() { + let mut instance = create_module_1(); + let result = c60_l99_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 100 +fn c61_l100_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c61_l100_action_invoke"); + let result = instance.call("rem_s", &[Value::I64(0 as i64), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c61_l100_assert_trap() { + let mut instance = create_module_1(); + let result = c61_l100_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 101 +fn c62_l101_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c62_l101_action_invoke"); + let result = instance.call("rem_s", &[Value::I64(9223372036854775807 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 102 +fn c63_l102_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c63_l102_action_invoke"); + let result = instance.call("rem_s", &[Value::I64(1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 103 +fn c64_l103_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c64_l103_action_invoke"); + let result = instance.call("rem_s", &[Value::I64(0 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 104 +fn c65_l104_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c65_l104_action_invoke"); + let result = instance.call("rem_s", &[Value::I64(0 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 105 +fn c66_l105_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c66_l105_action_invoke"); + let result = instance.call("rem_s", &[Value::I64(-1 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 106 +fn c67_l106_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c67_l106_action_invoke"); + let result = instance.call("rem_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 107 +fn c68_l107_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c68_l107_action_invoke"); + let result = instance.call("rem_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(2 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 108 +fn c69_l108_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c69_l108_action_invoke"); + let result = instance.call("rem_s", &[Value::I64(-9223372036854775807 as i64), Value::I64(1000 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-807 as i64)))); + result.map(|_| ()) +} + +// Line 109 +fn c70_l109_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c70_l109_action_invoke"); + let result = instance.call("rem_s", &[Value::I64(5 as i64), Value::I64(2 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 110 +fn c71_l110_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c71_l110_action_invoke"); + let result = instance.call("rem_s", &[Value::I64(-5 as i64), Value::I64(2 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); + result.map(|_| ()) +} + +// Line 111 +fn c72_l111_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c72_l111_action_invoke"); + let result = instance.call("rem_s", &[Value::I64(5 as i64), Value::I64(-2 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 112 +fn c73_l112_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c73_l112_action_invoke"); + let result = instance.call("rem_s", &[Value::I64(-5 as i64), Value::I64(-2 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); + result.map(|_| ()) +} + +// Line 113 +fn c74_l113_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c74_l113_action_invoke"); + let result = instance.call("rem_s", &[Value::I64(7 as i64), Value::I64(3 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 114 +fn c75_l114_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c75_l114_action_invoke"); + let result = instance.call("rem_s", &[Value::I64(-7 as i64), Value::I64(3 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); + result.map(|_| ()) +} + +// Line 115 +fn c76_l115_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c76_l115_action_invoke"); + let result = instance.call("rem_s", &[Value::I64(7 as i64), Value::I64(-3 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 116 +fn c77_l116_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c77_l116_action_invoke"); + let result = instance.call("rem_s", &[Value::I64(-7 as i64), Value::I64(-3 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); + result.map(|_| ()) +} + +// Line 117 +fn c78_l117_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c78_l117_action_invoke"); + let result = instance.call("rem_s", &[Value::I64(11 as i64), Value::I64(5 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 118 +fn c79_l118_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c79_l118_action_invoke"); + let result = instance.call("rem_s", &[Value::I64(17 as i64), Value::I64(7 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(3 as i64)))); + result.map(|_| ()) +} + +// Line 120 +fn c80_l120_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c80_l120_action_invoke"); + let result = instance.call("rem_u", &[Value::I64(1 as i64), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c80_l120_assert_trap() { + let mut instance = create_module_1(); + let result = c80_l120_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 121 +fn c81_l121_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c81_l121_action_invoke"); + let result = instance.call("rem_u", &[Value::I64(0 as i64), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c81_l121_assert_trap() { + let mut instance = create_module_1(); + let result = c81_l121_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 122 +fn c82_l122_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c82_l122_action_invoke"); + let result = instance.call("rem_u", &[Value::I64(1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 123 +fn c83_l123_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c83_l123_action_invoke"); + let result = instance.call("rem_u", &[Value::I64(0 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 124 +fn c84_l124_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c84_l124_action_invoke"); + let result = instance.call("rem_u", &[Value::I64(-1 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 125 +fn c85_l125_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c85_l125_action_invoke"); + let result = instance.call("rem_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-9223372036854775808 as i64)))); + result.map(|_| ()) +} + +// Line 126 +fn c86_l126_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c86_l126_action_invoke"); + let result = instance.call("rem_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(2 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 127 +fn c87_l127_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c87_l127_action_invoke"); + let result = instance.call("rem_u", &[Value::I64(-8074936608141340688 as i64), Value::I64(4294967297 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(2147483649 as i64)))); + result.map(|_| ()) +} + +// Line 128 +fn c88_l128_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c88_l128_action_invoke"); + let result = instance.call("rem_u", &[Value::I64(-9223372036854775807 as i64), Value::I64(1000 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(809 as i64)))); + result.map(|_| ()) +} + +// Line 129 +fn c89_l129_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c89_l129_action_invoke"); + let result = instance.call("rem_u", &[Value::I64(5 as i64), Value::I64(2 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 130 +fn c90_l130_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c90_l130_action_invoke"); + let result = instance.call("rem_u", &[Value::I64(-5 as i64), Value::I64(2 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 131 +fn c91_l131_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c91_l131_action_invoke"); + let result = instance.call("rem_u", &[Value::I64(5 as i64), Value::I64(-2 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(5 as i64)))); + result.map(|_| ()) +} + +// Line 132 +fn c92_l132_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c92_l132_action_invoke"); + let result = instance.call("rem_u", &[Value::I64(-5 as i64), Value::I64(-2 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-5 as i64)))); + result.map(|_| ()) +} + +// Line 133 +fn c93_l133_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c93_l133_action_invoke"); + let result = instance.call("rem_u", &[Value::I64(7 as i64), Value::I64(3 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 134 +fn c94_l134_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c94_l134_action_invoke"); + let result = instance.call("rem_u", &[Value::I64(11 as i64), Value::I64(5 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 135 +fn c95_l135_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c95_l135_action_invoke"); + let result = instance.call("rem_u", &[Value::I64(17 as i64), Value::I64(7 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(3 as i64)))); + result.map(|_| ()) +} + +// Line 137 +fn c96_l137_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c96_l137_action_invoke"); + let result = instance.call("and", &[Value::I64(1 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 138 +fn c97_l138_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c97_l138_action_invoke"); + let result = instance.call("and", &[Value::I64(0 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 139 +fn c98_l139_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c98_l139_action_invoke"); + let result = instance.call("and", &[Value::I64(1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 140 +fn c99_l140_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c99_l140_action_invoke"); + let result = instance.call("and", &[Value::I64(0 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 141 +fn c100_l141_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c100_l141_action_invoke"); + let result = instance.call("and", &[Value::I64(9223372036854775807 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 142 +fn c101_l142_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c101_l142_action_invoke"); + let result = instance.call("and", &[Value::I64(9223372036854775807 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(9223372036854775807 as i64)))); + result.map(|_| ()) +} + +// Line 143 +fn c102_l143_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c102_l143_action_invoke"); + let result = instance.call("and", &[Value::I64(4042326015 as i64), Value::I64(4294963440 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(4042322160 as i64)))); + result.map(|_| ()) +} + +// Line 144 +fn c103_l144_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c103_l144_action_invoke"); + let result = instance.call("and", &[Value::I64(-1 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); + result.map(|_| ()) +} + +// Line 146 +fn c104_l146_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c104_l146_action_invoke"); + let result = instance.call("or", &[Value::I64(1 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 147 +fn c105_l147_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c105_l147_action_invoke"); + let result = instance.call("or", &[Value::I64(0 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 148 +fn c106_l148_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c106_l148_action_invoke"); + let result = instance.call("or", &[Value::I64(1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 149 +fn c107_l149_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c107_l149_action_invoke"); + let result = instance.call("or", &[Value::I64(0 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 150 +fn c108_l150_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c108_l150_action_invoke"); + let result = instance.call("or", &[Value::I64(9223372036854775807 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); + result.map(|_| ()) +} + +// Line 151 +fn c109_l151_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c109_l151_action_invoke"); + let result = instance.call("or", &[Value::I64(-9223372036854775808 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-9223372036854775808 as i64)))); + result.map(|_| ()) +} + +// Line 152 +fn c110_l152_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c110_l152_action_invoke"); + let result = instance.call("or", &[Value::I64(4042326015 as i64), Value::I64(4294963440 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(4294967295 as i64)))); + result.map(|_| ()) +} + +// Line 153 +fn c111_l153_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c111_l153_action_invoke"); + let result = instance.call("or", &[Value::I64(-1 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); + result.map(|_| ()) +} + +// Line 155 +fn c112_l155_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c112_l155_action_invoke"); + let result = instance.call("xor", &[Value::I64(1 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 156 +fn c113_l156_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c113_l156_action_invoke"); + let result = instance.call("xor", &[Value::I64(0 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 157 +fn c114_l157_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c114_l157_action_invoke"); + let result = instance.call("xor", &[Value::I64(1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 158 +fn c115_l158_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c115_l158_action_invoke"); + let result = instance.call("xor", &[Value::I64(0 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 159 +fn c116_l159_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c116_l159_action_invoke"); + let result = instance.call("xor", &[Value::I64(9223372036854775807 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); + result.map(|_| ()) +} + +// Line 160 +fn c117_l160_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c117_l160_action_invoke"); + let result = instance.call("xor", &[Value::I64(-9223372036854775808 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-9223372036854775808 as i64)))); + result.map(|_| ()) +} + +// Line 161 +fn c118_l161_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c118_l161_action_invoke"); + let result = instance.call("xor", &[Value::I64(-1 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(9223372036854775807 as i64)))); + result.map(|_| ()) +} + +// Line 162 +fn c119_l162_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c119_l162_action_invoke"); + let result = instance.call("xor", &[Value::I64(-1 as i64), Value::I64(9223372036854775807 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-9223372036854775808 as i64)))); + result.map(|_| ()) +} + +// Line 163 +fn c120_l163_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c120_l163_action_invoke"); + let result = instance.call("xor", &[Value::I64(4042326015 as i64), Value::I64(4294963440 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(252645135 as i64)))); + result.map(|_| ()) +} + +// Line 164 +fn c121_l164_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c121_l164_action_invoke"); + let result = instance.call("xor", &[Value::I64(-1 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 166 +fn c122_l166_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c122_l166_action_invoke"); + let result = instance.call("shl", &[Value::I64(1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(2 as i64)))); + result.map(|_| ()) +} + +// Line 167 +fn c123_l167_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c123_l167_action_invoke"); + let result = instance.call("shl", &[Value::I64(1 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 168 +fn c124_l168_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c124_l168_action_invoke"); + let result = instance.call("shl", &[Value::I64(9223372036854775807 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-2 as i64)))); + result.map(|_| ()) +} + +// Line 169 +fn c125_l169_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c125_l169_action_invoke"); + let result = instance.call("shl", &[Value::I64(-1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-2 as i64)))); + result.map(|_| ()) +} + +// Line 170 +fn c126_l170_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c126_l170_action_invoke"); + let result = instance.call("shl", &[Value::I64(-9223372036854775808 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 171 +fn c127_l171_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c127_l171_action_invoke"); + let result = instance.call("shl", &[Value::I64(4611686018427387904 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-9223372036854775808 as i64)))); + result.map(|_| ()) +} + +// Line 172 +fn c128_l172_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c128_l172_action_invoke"); + let result = instance.call("shl", &[Value::I64(1 as i64), Value::I64(63 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-9223372036854775808 as i64)))); + result.map(|_| ()) +} + +// Line 173 +fn c129_l173_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c129_l173_action_invoke"); + let result = instance.call("shl", &[Value::I64(1 as i64), Value::I64(64 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 174 +fn c130_l174_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c130_l174_action_invoke"); + let result = instance.call("shl", &[Value::I64(1 as i64), Value::I64(65 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(2 as i64)))); + result.map(|_| ()) +} + +// Line 175 +fn c131_l175_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c131_l175_action_invoke"); + let result = instance.call("shl", &[Value::I64(1 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-9223372036854775808 as i64)))); + result.map(|_| ()) +} + +// Line 176 +fn c132_l176_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c132_l176_action_invoke"); + let result = instance.call("shl", &[Value::I64(1 as i64), Value::I64(9223372036854775807 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-9223372036854775808 as i64)))); + result.map(|_| ()) +} + +// Line 178 +fn c133_l178_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c133_l178_action_invoke"); + let result = instance.call("shr_s", &[Value::I64(1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 179 +fn c134_l179_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c134_l179_action_invoke"); + let result = instance.call("shr_s", &[Value::I64(1 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 180 +fn c135_l180_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c135_l180_action_invoke"); + let result = instance.call("shr_s", &[Value::I64(-1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); + result.map(|_| ()) +} + +// Line 181 +fn c136_l181_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c136_l181_action_invoke"); + let result = instance.call("shr_s", &[Value::I64(9223372036854775807 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(4611686018427387903 as i64)))); + result.map(|_| ()) +} + +// Line 182 +fn c137_l182_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c137_l182_action_invoke"); + let result = instance.call("shr_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-4611686018427387904 as i64)))); + result.map(|_| ()) +} + +// Line 183 +fn c138_l183_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c138_l183_action_invoke"); + let result = instance.call("shr_s", &[Value::I64(4611686018427387904 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(2305843009213693952 as i64)))); + result.map(|_| ()) +} + +// Line 184 +fn c139_l184_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c139_l184_action_invoke"); + let result = instance.call("shr_s", &[Value::I64(1 as i64), Value::I64(64 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 185 +fn c140_l185_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c140_l185_action_invoke"); + let result = instance.call("shr_s", &[Value::I64(1 as i64), Value::I64(65 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 186 +fn c141_l186_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c141_l186_action_invoke"); + let result = instance.call("shr_s", &[Value::I64(1 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 187 +fn c142_l187_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c142_l187_action_invoke"); + let result = instance.call("shr_s", &[Value::I64(1 as i64), Value::I64(9223372036854775807 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 188 +fn c143_l188_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c143_l188_action_invoke"); + let result = instance.call("shr_s", &[Value::I64(1 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 189 +fn c144_l189_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c144_l189_action_invoke"); + let result = instance.call("shr_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(63 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); + result.map(|_| ()) +} + +// Line 190 +fn c145_l190_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c145_l190_action_invoke"); + let result = instance.call("shr_s", &[Value::I64(-1 as i64), Value::I64(64 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); + result.map(|_| ()) +} + +// Line 191 +fn c146_l191_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c146_l191_action_invoke"); + let result = instance.call("shr_s", &[Value::I64(-1 as i64), Value::I64(65 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); + result.map(|_| ()) +} + +// Line 192 +fn c147_l192_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c147_l192_action_invoke"); + let result = instance.call("shr_s", &[Value::I64(-1 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); + result.map(|_| ()) +} + +// Line 193 +fn c148_l193_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c148_l193_action_invoke"); + let result = instance.call("shr_s", &[Value::I64(-1 as i64), Value::I64(9223372036854775807 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); + result.map(|_| ()) +} + +// Line 194 +fn c149_l194_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c149_l194_action_invoke"); + let result = instance.call("shr_s", &[Value::I64(-1 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); + result.map(|_| ()) +} + +// Line 196 +fn c150_l196_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c150_l196_action_invoke"); + let result = instance.call("shr_u", &[Value::I64(1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 197 +fn c151_l197_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c151_l197_action_invoke"); + let result = instance.call("shr_u", &[Value::I64(1 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 198 +fn c152_l198_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c152_l198_action_invoke"); + let result = instance.call("shr_u", &[Value::I64(-1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(9223372036854775807 as i64)))); + result.map(|_| ()) +} + +// Line 199 +fn c153_l199_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c153_l199_action_invoke"); + let result = instance.call("shr_u", &[Value::I64(9223372036854775807 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(4611686018427387903 as i64)))); + result.map(|_| ()) +} + +// Line 200 +fn c154_l200_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c154_l200_action_invoke"); + let result = instance.call("shr_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(4611686018427387904 as i64)))); + result.map(|_| ()) +} + +// Line 201 +fn c155_l201_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c155_l201_action_invoke"); + let result = instance.call("shr_u", &[Value::I64(4611686018427387904 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(2305843009213693952 as i64)))); + result.map(|_| ()) +} + +// Line 202 +fn c156_l202_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c156_l202_action_invoke"); + let result = instance.call("shr_u", &[Value::I64(1 as i64), Value::I64(64 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 203 +fn c157_l203_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c157_l203_action_invoke"); + let result = instance.call("shr_u", &[Value::I64(1 as i64), Value::I64(65 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 204 +fn c158_l204_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c158_l204_action_invoke"); + let result = instance.call("shr_u", &[Value::I64(1 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 205 +fn c159_l205_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c159_l205_action_invoke"); + let result = instance.call("shr_u", &[Value::I64(1 as i64), Value::I64(9223372036854775807 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 206 +fn c160_l206_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c160_l206_action_invoke"); + let result = instance.call("shr_u", &[Value::I64(1 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 207 +fn c161_l207_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c161_l207_action_invoke"); + let result = instance.call("shr_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(63 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 208 +fn c162_l208_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c162_l208_action_invoke"); + let result = instance.call("shr_u", &[Value::I64(-1 as i64), Value::I64(64 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); + result.map(|_| ()) +} + +// Line 209 +fn c163_l209_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c163_l209_action_invoke"); + let result = instance.call("shr_u", &[Value::I64(-1 as i64), Value::I64(65 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(9223372036854775807 as i64)))); + result.map(|_| ()) +} + +// Line 210 +fn c164_l210_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c164_l210_action_invoke"); + let result = instance.call("shr_u", &[Value::I64(-1 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 211 +fn c165_l211_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c165_l211_action_invoke"); + let result = instance.call("shr_u", &[Value::I64(-1 as i64), Value::I64(9223372036854775807 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 212 +fn c166_l212_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c166_l212_action_invoke"); + let result = instance.call("shr_u", &[Value::I64(-1 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); + result.map(|_| ()) +} + +// Line 214 +fn c167_l214_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c167_l214_action_invoke"); + let result = instance.call("rotl", &[Value::I64(1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(2 as i64)))); + result.map(|_| ()) +} + +// Line 215 +fn c168_l215_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c168_l215_action_invoke"); + let result = instance.call("rotl", &[Value::I64(1 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 216 +fn c169_l216_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c169_l216_action_invoke"); + let result = instance.call("rotl", &[Value::I64(-1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); + result.map(|_| ()) +} + +// Line 217 +fn c170_l217_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c170_l217_action_invoke"); + let result = instance.call("rotl", &[Value::I64(1 as i64), Value::I64(64 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 218 +fn c171_l218_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c171_l218_action_invoke"); + let result = instance.call("rotl", &[Value::I64(-6067025490386449714 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(6312693092936652189 as i64)))); + result.map(|_| ()) +} + +// Line 219 +fn c172_l219_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c172_l219_action_invoke"); + let result = instance.call("rotl", &[Value::I64(-144115184384868352 as i64), Value::I64(4 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-2305842950157893617 as i64)))); + result.map(|_| ()) +} + +// Line 220 +fn c173_l220_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c173_l220_action_invoke"); + let result = instance.call("rotl", &[Value::I64(-6067173104435169271 as i64), Value::I64(53 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(87109505680009935 as i64)))); + result.map(|_| ()) +} + +// Line 221 +fn c174_l221_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c174_l221_action_invoke"); + let result = instance.call("rotl", &[Value::I64(-6066028401059725156 as i64), Value::I64(63 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(6190357836324913230 as i64)))); + result.map(|_| ()) +} + +// Line 222 +fn c175_l222_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c175_l222_action_invoke"); + let result = instance.call("rotl", &[Value::I64(-6067173104435169271 as i64), Value::I64(245 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(87109505680009935 as i64)))); + result.map(|_| ()) +} + +// Line 223 +fn c176_l223_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c176_l223_action_invoke"); + let result = instance.call("rotl", &[Value::I64(-6067067139002042359 as i64), Value::I64(-19 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-3530481836149793302 as i64)))); + result.map(|_| ()) +} + +// Line 224 +fn c177_l224_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c177_l224_action_invoke"); + let result = instance.call("rotl", &[Value::I64(-6066028401059725156 as i64), Value::I64(-9223372036854775745 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(6190357836324913230 as i64)))); + result.map(|_| ()) +} + +// Line 225 +fn c178_l225_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c178_l225_action_invoke"); + let result = instance.call("rotl", &[Value::I64(1 as i64), Value::I64(63 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-9223372036854775808 as i64)))); + result.map(|_| ()) +} + +// Line 226 +fn c179_l226_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c179_l226_action_invoke"); + let result = instance.call("rotl", &[Value::I64(-9223372036854775808 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 228 +fn c180_l228_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c180_l228_action_invoke"); + let result = instance.call("rotr", &[Value::I64(1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-9223372036854775808 as i64)))); + result.map(|_| ()) +} + +// Line 229 +fn c181_l229_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c181_l229_action_invoke"); + let result = instance.call("rotr", &[Value::I64(1 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 230 +fn c182_l230_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c182_l230_action_invoke"); + let result = instance.call("rotr", &[Value::I64(-1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); + result.map(|_| ()) +} + +// Line 231 +fn c183_l231_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c183_l231_action_invoke"); + let result = instance.call("rotr", &[Value::I64(1 as i64), Value::I64(64 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 232 +fn c184_l232_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c184_l232_action_invoke"); + let result = instance.call("rotr", &[Value::I64(-6067025490386449714 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(6189859291661550951 as i64)))); + result.map(|_| ()) +} + +// Line 233 +fn c185_l233_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c185_l233_action_invoke"); + let result = instance.call("rotr", &[Value::I64(-144115184384868352 as i64), Value::I64(4 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1143914305582792704 as i64)))); + result.map(|_| ()) +} + +// Line 234 +fn c186_l234_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c186_l234_action_invoke"); + let result = instance.call("rotr", &[Value::I64(-6067173104435169271 as i64), Value::I64(53 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(7534987797011123550 as i64)))); + result.map(|_| ()) +} + +// Line 235 +fn c187_l235_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c187_l235_action_invoke"); + let result = instance.call("rotr", &[Value::I64(-6066028401059725156 as i64), Value::I64(63 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(6314687271590101305 as i64)))); + result.map(|_| ()) +} + +// Line 236 +fn c188_l236_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c188_l236_action_invoke"); + let result = instance.call("rotr", &[Value::I64(-6067173104435169271 as i64), Value::I64(245 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(7534987797011123550 as i64)))); + result.map(|_| ()) +} + +// Line 237 +fn c189_l237_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c189_l237_action_invoke"); + let result = instance.call("rotr", &[Value::I64(-6067067139002042359 as i64), Value::I64(-19 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-7735078922541506965 as i64)))); + result.map(|_| ()) +} + +// Line 238 +fn c190_l238_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c190_l238_action_invoke"); + let result = instance.call("rotr", &[Value::I64(-6066028401059725156 as i64), Value::I64(-9223372036854775745 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(6314687271590101305 as i64)))); + result.map(|_| ()) +} + +// Line 239 +fn c191_l239_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c191_l239_action_invoke"); + let result = instance.call("rotr", &[Value::I64(1 as i64), Value::I64(63 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(2 as i64)))); + result.map(|_| ()) +} + +// Line 240 +fn c192_l240_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c192_l240_action_invoke"); + let result = instance.call("rotr", &[Value::I64(-9223372036854775808 as i64), Value::I64(63 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 242 +fn c193_l242_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c193_l242_action_invoke"); + let result = instance.call("clz", &[Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 243 +fn c194_l243_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c194_l243_action_invoke"); + let result = instance.call("clz", &[Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(64 as i64)))); + result.map(|_| ()) +} + +// Line 244 +fn c195_l244_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c195_l244_action_invoke"); + let result = instance.call("clz", &[Value::I64(32768 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(48 as i64)))); + result.map(|_| ()) +} + +// Line 245 +fn c196_l245_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c196_l245_action_invoke"); + let result = instance.call("clz", &[Value::I64(255 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(56 as i64)))); + result.map(|_| ()) +} + +// Line 246 +fn c197_l246_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c197_l246_action_invoke"); + let result = instance.call("clz", &[Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 247 +fn c198_l247_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c198_l247_action_invoke"); + let result = instance.call("clz", &[Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(63 as i64)))); + result.map(|_| ()) +} + +// Line 248 +fn c199_l248_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c199_l248_action_invoke"); + let result = instance.call("clz", &[Value::I64(2 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(62 as i64)))); + result.map(|_| ()) +} + +// Line 249 +fn c200_l249_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c200_l249_action_invoke"); + let result = instance.call("clz", &[Value::I64(9223372036854775807 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 251 +fn c201_l251_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c201_l251_action_invoke"); + let result = instance.call("ctz", &[Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 252 +fn c202_l252_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c202_l252_action_invoke"); + let result = instance.call("ctz", &[Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(64 as i64)))); + result.map(|_| ()) +} + +// Line 253 +fn c203_l253_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c203_l253_action_invoke"); + let result = instance.call("ctz", &[Value::I64(32768 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(15 as i64)))); + result.map(|_| ()) +} + +// Line 254 +fn c204_l254_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c204_l254_action_invoke"); + let result = instance.call("ctz", &[Value::I64(65536 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(16 as i64)))); + result.map(|_| ()) +} + +// Line 255 +fn c205_l255_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c205_l255_action_invoke"); + let result = instance.call("ctz", &[Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(63 as i64)))); + result.map(|_| ()) +} + +// Line 256 +fn c206_l256_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c206_l256_action_invoke"); + let result = instance.call("ctz", &[Value::I64(9223372036854775807 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 258 +fn c207_l258_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c207_l258_action_invoke"); + let result = instance.call("popcnt", &[Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(64 as i64)))); + result.map(|_| ()) +} + +// Line 259 +fn c208_l259_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c208_l259_action_invoke"); + let result = instance.call("popcnt", &[Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 260 +fn c209_l260_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c209_l260_action_invoke"); + let result = instance.call("popcnt", &[Value::I64(32768 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 261 +fn c210_l261_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c210_l261_action_invoke"); + let result = instance.call("popcnt", &[Value::I64(-9223231297218904064 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(4 as i64)))); + result.map(|_| ()) +} + +// Line 262 +fn c211_l262_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c211_l262_action_invoke"); + let result = instance.call("popcnt", &[Value::I64(9223372036854775807 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(63 as i64)))); + result.map(|_| ()) +} + +// Line 263 +fn c212_l263_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c212_l263_action_invoke"); + let result = instance.call("popcnt", &[Value::I64(-6148914692668172971 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(32 as i64)))); + result.map(|_| ()) +} + +// Line 264 +fn c213_l264_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c213_l264_action_invoke"); + let result = instance.call("popcnt", &[Value::I64(-7378697629197489494 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(32 as i64)))); + result.map(|_| ()) +} + +// Line 265 +fn c214_l265_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c214_l265_action_invoke"); + let result = instance.call("popcnt", &[Value::I64(-2401053088876216593 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(48 as i64)))); + result.map(|_| ()) +} + +// Line 267 +fn c215_l267_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c215_l267_action_invoke"); + let result = instance.call("eqz", &[Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 268 +fn c216_l268_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c216_l268_action_invoke"); + let result = instance.call("eqz", &[Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 269 +fn c217_l269_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c217_l269_action_invoke"); + let result = instance.call("eqz", &[Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 270 +fn c218_l270_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c218_l270_action_invoke"); + let result = instance.call("eqz", &[Value::I64(9223372036854775807 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 271 +fn c219_l271_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c219_l271_action_invoke"); + let result = instance.call("eqz", &[Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 273 +fn c220_l273_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c220_l273_action_invoke"); + let result = instance.call("eq", &[Value::I64(0 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 274 +fn c221_l274_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c221_l274_action_invoke"); + let result = instance.call("eq", &[Value::I64(1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 275 +fn c222_l275_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c222_l275_action_invoke"); + let result = instance.call("eq", &[Value::I64(-1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 276 +fn c223_l276_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c223_l276_action_invoke"); + let result = instance.call("eq", &[Value::I64(-9223372036854775808 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 277 +fn c224_l277_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c224_l277_action_invoke"); + let result = instance.call("eq", &[Value::I64(9223372036854775807 as i64), Value::I64(9223372036854775807 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 278 +fn c225_l278_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c225_l278_action_invoke"); + let result = instance.call("eq", &[Value::I64(-1 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 279 +fn c226_l279_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c226_l279_action_invoke"); + let result = instance.call("eq", &[Value::I64(1 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 280 +fn c227_l280_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c227_l280_action_invoke"); + let result = instance.call("eq", &[Value::I64(0 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 281 +fn c228_l281_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c228_l281_action_invoke"); + let result = instance.call("eq", &[Value::I64(-9223372036854775808 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 282 +fn c229_l282_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c229_l282_action_invoke"); + let result = instance.call("eq", &[Value::I64(0 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 283 +fn c230_l283_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c230_l283_action_invoke"); + let result = instance.call("eq", &[Value::I64(-9223372036854775808 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 284 +fn c231_l284_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c231_l284_action_invoke"); + let result = instance.call("eq", &[Value::I64(-1 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 285 +fn c232_l285_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c232_l285_action_invoke"); + let result = instance.call("eq", &[Value::I64(-9223372036854775808 as i64), Value::I64(9223372036854775807 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 286 +fn c233_l286_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c233_l286_action_invoke"); + let result = instance.call("eq", &[Value::I64(9223372036854775807 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 288 +fn c234_l288_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c234_l288_action_invoke"); + let result = instance.call("ne", &[Value::I64(0 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 289 +fn c235_l289_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c235_l289_action_invoke"); + let result = instance.call("ne", &[Value::I64(1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 290 +fn c236_l290_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c236_l290_action_invoke"); + let result = instance.call("ne", &[Value::I64(-1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 291 +fn c237_l291_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c237_l291_action_invoke"); + let result = instance.call("ne", &[Value::I64(-9223372036854775808 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 292 +fn c238_l292_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c238_l292_action_invoke"); + let result = instance.call("ne", &[Value::I64(9223372036854775807 as i64), Value::I64(9223372036854775807 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 293 +fn c239_l293_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c239_l293_action_invoke"); + let result = instance.call("ne", &[Value::I64(-1 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 294 +fn c240_l294_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c240_l294_action_invoke"); + let result = instance.call("ne", &[Value::I64(1 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 295 +fn c241_l295_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c241_l295_action_invoke"); + let result = instance.call("ne", &[Value::I64(0 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 296 +fn c242_l296_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c242_l296_action_invoke"); + let result = instance.call("ne", &[Value::I64(-9223372036854775808 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 297 +fn c243_l297_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c243_l297_action_invoke"); + let result = instance.call("ne", &[Value::I64(0 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 298 +fn c244_l298_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c244_l298_action_invoke"); + let result = instance.call("ne", &[Value::I64(-9223372036854775808 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 299 +fn c245_l299_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c245_l299_action_invoke"); + let result = instance.call("ne", &[Value::I64(-1 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 300 +fn c246_l300_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c246_l300_action_invoke"); + let result = instance.call("ne", &[Value::I64(-9223372036854775808 as i64), Value::I64(9223372036854775807 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 301 +fn c247_l301_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c247_l301_action_invoke"); + let result = instance.call("ne", &[Value::I64(9223372036854775807 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 303 +fn c248_l303_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c248_l303_action_invoke"); + let result = instance.call("lt_s", &[Value::I64(0 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 304 +fn c249_l304_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c249_l304_action_invoke"); + let result = instance.call("lt_s", &[Value::I64(1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 305 +fn c250_l305_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c250_l305_action_invoke"); + let result = instance.call("lt_s", &[Value::I64(-1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 306 +fn c251_l306_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c251_l306_action_invoke"); + let result = instance.call("lt_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 307 +fn c252_l307_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c252_l307_action_invoke"); + let result = instance.call("lt_s", &[Value::I64(9223372036854775807 as i64), Value::I64(9223372036854775807 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 308 +fn c253_l308_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c253_l308_action_invoke"); + let result = instance.call("lt_s", &[Value::I64(-1 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 309 +fn c254_l309_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c254_l309_action_invoke"); + let result = instance.call("lt_s", &[Value::I64(1 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 310 +fn c255_l310_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c255_l310_action_invoke"); + let result = instance.call("lt_s", &[Value::I64(0 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 311 +fn c256_l311_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c256_l311_action_invoke"); + let result = instance.call("lt_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 312 +fn c257_l312_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c257_l312_action_invoke"); + let result = instance.call("lt_s", &[Value::I64(0 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 313 +fn c258_l313_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c258_l313_action_invoke"); + let result = instance.call("lt_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 314 +fn c259_l314_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c259_l314_action_invoke"); + let result = instance.call("lt_s", &[Value::I64(-1 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 315 +fn c260_l315_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c260_l315_action_invoke"); + let result = instance.call("lt_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(9223372036854775807 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 316 +fn c261_l316_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c261_l316_action_invoke"); + let result = instance.call("lt_s", &[Value::I64(9223372036854775807 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 318 +fn c262_l318_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c262_l318_action_invoke"); + let result = instance.call("lt_u", &[Value::I64(0 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 319 +fn c263_l319_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c263_l319_action_invoke"); + let result = instance.call("lt_u", &[Value::I64(1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 320 +fn c264_l320_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c264_l320_action_invoke"); + let result = instance.call("lt_u", &[Value::I64(-1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 321 +fn c265_l321_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c265_l321_action_invoke"); + let result = instance.call("lt_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 322 +fn c266_l322_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c266_l322_action_invoke"); + let result = instance.call("lt_u", &[Value::I64(9223372036854775807 as i64), Value::I64(9223372036854775807 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 323 +fn c267_l323_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c267_l323_action_invoke"); + let result = instance.call("lt_u", &[Value::I64(-1 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 324 +fn c268_l324_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c268_l324_action_invoke"); + let result = instance.call("lt_u", &[Value::I64(1 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 325 +fn c269_l325_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c269_l325_action_invoke"); + let result = instance.call("lt_u", &[Value::I64(0 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 326 +fn c270_l326_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c270_l326_action_invoke"); + let result = instance.call("lt_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 327 +fn c271_l327_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c271_l327_action_invoke"); + let result = instance.call("lt_u", &[Value::I64(0 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 328 +fn c272_l328_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c272_l328_action_invoke"); + let result = instance.call("lt_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 329 +fn c273_l329_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c273_l329_action_invoke"); + let result = instance.call("lt_u", &[Value::I64(-1 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 330 +fn c274_l330_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c274_l330_action_invoke"); + let result = instance.call("lt_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(9223372036854775807 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 331 +fn c275_l331_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c275_l331_action_invoke"); + let result = instance.call("lt_u", &[Value::I64(9223372036854775807 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 333 +fn c276_l333_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c276_l333_action_invoke"); + let result = instance.call("le_s", &[Value::I64(0 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 334 +fn c277_l334_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c277_l334_action_invoke"); + let result = instance.call("le_s", &[Value::I64(1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 335 +fn c278_l335_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c278_l335_action_invoke"); + let result = instance.call("le_s", &[Value::I64(-1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 336 +fn c279_l336_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c279_l336_action_invoke"); + let result = instance.call("le_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 337 +fn c280_l337_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c280_l337_action_invoke"); + let result = instance.call("le_s", &[Value::I64(9223372036854775807 as i64), Value::I64(9223372036854775807 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 338 +fn c281_l338_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c281_l338_action_invoke"); + let result = instance.call("le_s", &[Value::I64(-1 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 339 +fn c282_l339_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c282_l339_action_invoke"); + let result = instance.call("le_s", &[Value::I64(1 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 340 +fn c283_l340_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c283_l340_action_invoke"); + let result = instance.call("le_s", &[Value::I64(0 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 341 +fn c284_l341_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c284_l341_action_invoke"); + let result = instance.call("le_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 342 +fn c285_l342_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c285_l342_action_invoke"); + let result = instance.call("le_s", &[Value::I64(0 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 343 +fn c286_l343_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c286_l343_action_invoke"); + let result = instance.call("le_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 344 +fn c287_l344_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c287_l344_action_invoke"); + let result = instance.call("le_s", &[Value::I64(-1 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 345 +fn c288_l345_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c288_l345_action_invoke"); + let result = instance.call("le_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(9223372036854775807 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 346 +fn c289_l346_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c289_l346_action_invoke"); + let result = instance.call("le_s", &[Value::I64(9223372036854775807 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 348 +fn c290_l348_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c290_l348_action_invoke"); + let result = instance.call("le_u", &[Value::I64(0 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 349 +fn c291_l349_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c291_l349_action_invoke"); + let result = instance.call("le_u", &[Value::I64(1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 350 +fn c292_l350_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c292_l350_action_invoke"); + let result = instance.call("le_u", &[Value::I64(-1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 351 +fn c293_l351_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c293_l351_action_invoke"); + let result = instance.call("le_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 352 +fn c294_l352_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c294_l352_action_invoke"); + let result = instance.call("le_u", &[Value::I64(9223372036854775807 as i64), Value::I64(9223372036854775807 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 353 +fn c295_l353_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c295_l353_action_invoke"); + let result = instance.call("le_u", &[Value::I64(-1 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 354 +fn c296_l354_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c296_l354_action_invoke"); + let result = instance.call("le_u", &[Value::I64(1 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 355 +fn c297_l355_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c297_l355_action_invoke"); + let result = instance.call("le_u", &[Value::I64(0 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 356 +fn c298_l356_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c298_l356_action_invoke"); + let result = instance.call("le_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 357 +fn c299_l357_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c299_l357_action_invoke"); + let result = instance.call("le_u", &[Value::I64(0 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 358 +fn c300_l358_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c300_l358_action_invoke"); + let result = instance.call("le_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 359 +fn c301_l359_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c301_l359_action_invoke"); + let result = instance.call("le_u", &[Value::I64(-1 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 360 +fn c302_l360_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c302_l360_action_invoke"); + let result = instance.call("le_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(9223372036854775807 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 361 +fn c303_l361_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c303_l361_action_invoke"); + let result = instance.call("le_u", &[Value::I64(9223372036854775807 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 363 +fn c304_l363_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c304_l363_action_invoke"); + let result = instance.call("gt_s", &[Value::I64(0 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 364 +fn c305_l364_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c305_l364_action_invoke"); + let result = instance.call("gt_s", &[Value::I64(1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 365 +fn c306_l365_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c306_l365_action_invoke"); + let result = instance.call("gt_s", &[Value::I64(-1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 366 +fn c307_l366_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c307_l366_action_invoke"); + let result = instance.call("gt_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 367 +fn c308_l367_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c308_l367_action_invoke"); + let result = instance.call("gt_s", &[Value::I64(9223372036854775807 as i64), Value::I64(9223372036854775807 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 368 +fn c309_l368_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c309_l368_action_invoke"); + let result = instance.call("gt_s", &[Value::I64(-1 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 369 +fn c310_l369_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c310_l369_action_invoke"); + let result = instance.call("gt_s", &[Value::I64(1 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 370 +fn c311_l370_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c311_l370_action_invoke"); + let result = instance.call("gt_s", &[Value::I64(0 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 371 +fn c312_l371_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c312_l371_action_invoke"); + let result = instance.call("gt_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 372 +fn c313_l372_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c313_l372_action_invoke"); + let result = instance.call("gt_s", &[Value::I64(0 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 373 +fn c314_l373_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c314_l373_action_invoke"); + let result = instance.call("gt_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 374 +fn c315_l374_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c315_l374_action_invoke"); + let result = instance.call("gt_s", &[Value::I64(-1 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 375 +fn c316_l375_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c316_l375_action_invoke"); + let result = instance.call("gt_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(9223372036854775807 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 376 +fn c317_l376_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c317_l376_action_invoke"); + let result = instance.call("gt_s", &[Value::I64(9223372036854775807 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 378 +fn c318_l378_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c318_l378_action_invoke"); + let result = instance.call("gt_u", &[Value::I64(0 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 379 +fn c319_l379_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c319_l379_action_invoke"); + let result = instance.call("gt_u", &[Value::I64(1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 380 +fn c320_l380_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c320_l380_action_invoke"); + let result = instance.call("gt_u", &[Value::I64(-1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 381 +fn c321_l381_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c321_l381_action_invoke"); + let result = instance.call("gt_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 382 +fn c322_l382_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c322_l382_action_invoke"); + let result = instance.call("gt_u", &[Value::I64(9223372036854775807 as i64), Value::I64(9223372036854775807 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 383 +fn c323_l383_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c323_l383_action_invoke"); + let result = instance.call("gt_u", &[Value::I64(-1 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 384 +fn c324_l384_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c324_l384_action_invoke"); + let result = instance.call("gt_u", &[Value::I64(1 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 385 +fn c325_l385_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c325_l385_action_invoke"); + let result = instance.call("gt_u", &[Value::I64(0 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 386 +fn c326_l386_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c326_l386_action_invoke"); + let result = instance.call("gt_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 387 +fn c327_l387_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c327_l387_action_invoke"); + let result = instance.call("gt_u", &[Value::I64(0 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 388 +fn c328_l388_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c328_l388_action_invoke"); + let result = instance.call("gt_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 389 +fn c329_l389_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c329_l389_action_invoke"); + let result = instance.call("gt_u", &[Value::I64(-1 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 390 +fn c330_l390_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c330_l390_action_invoke"); + let result = instance.call("gt_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(9223372036854775807 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 391 +fn c331_l391_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c331_l391_action_invoke"); + let result = instance.call("gt_u", &[Value::I64(9223372036854775807 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 393 +fn c332_l393_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c332_l393_action_invoke"); + let result = instance.call("ge_s", &[Value::I64(0 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 394 +fn c333_l394_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c333_l394_action_invoke"); + let result = instance.call("ge_s", &[Value::I64(1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 395 +fn c334_l395_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c334_l395_action_invoke"); + let result = instance.call("ge_s", &[Value::I64(-1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 396 +fn c335_l396_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c335_l396_action_invoke"); + let result = instance.call("ge_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 397 +fn c336_l397_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c336_l397_action_invoke"); + let result = instance.call("ge_s", &[Value::I64(9223372036854775807 as i64), Value::I64(9223372036854775807 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 398 +fn c337_l398_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c337_l398_action_invoke"); + let result = instance.call("ge_s", &[Value::I64(-1 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 399 +fn c338_l399_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c338_l399_action_invoke"); + let result = instance.call("ge_s", &[Value::I64(1 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 400 +fn c339_l400_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c339_l400_action_invoke"); + let result = instance.call("ge_s", &[Value::I64(0 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 401 +fn c340_l401_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c340_l401_action_invoke"); + let result = instance.call("ge_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 402 +fn c341_l402_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c341_l402_action_invoke"); + let result = instance.call("ge_s", &[Value::I64(0 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 403 +fn c342_l403_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c342_l403_action_invoke"); + let result = instance.call("ge_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 404 +fn c343_l404_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c343_l404_action_invoke"); + let result = instance.call("ge_s", &[Value::I64(-1 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 405 +fn c344_l405_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c344_l405_action_invoke"); + let result = instance.call("ge_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(9223372036854775807 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 406 +fn c345_l406_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c345_l406_action_invoke"); + let result = instance.call("ge_s", &[Value::I64(9223372036854775807 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 408 +fn c346_l408_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c346_l408_action_invoke"); + let result = instance.call("ge_u", &[Value::I64(0 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 409 +fn c347_l409_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c347_l409_action_invoke"); + let result = instance.call("ge_u", &[Value::I64(1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 410 +fn c348_l410_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c348_l410_action_invoke"); + let result = instance.call("ge_u", &[Value::I64(-1 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 411 +fn c349_l411_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c349_l411_action_invoke"); + let result = instance.call("ge_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 412 +fn c350_l412_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c350_l412_action_invoke"); + let result = instance.call("ge_u", &[Value::I64(9223372036854775807 as i64), Value::I64(9223372036854775807 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 413 +fn c351_l413_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c351_l413_action_invoke"); + let result = instance.call("ge_u", &[Value::I64(-1 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 414 +fn c352_l414_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c352_l414_action_invoke"); + let result = instance.call("ge_u", &[Value::I64(1 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 415 +fn c353_l415_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c353_l415_action_invoke"); + let result = instance.call("ge_u", &[Value::I64(0 as i64), Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 416 +fn c354_l416_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c354_l416_action_invoke"); + let result = instance.call("ge_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 417 +fn c355_l417_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c355_l417_action_invoke"); + let result = instance.call("ge_u", &[Value::I64(0 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 418 +fn c356_l418_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c356_l418_action_invoke"); + let result = instance.call("ge_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(-1 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 419 +fn c357_l419_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c357_l419_action_invoke"); + let result = instance.call("ge_u", &[Value::I64(-1 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 420 +fn c358_l420_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c358_l420_action_invoke"); + let result = instance.call("ge_u", &[Value::I64(-9223372036854775808 as i64), Value::I64(9223372036854775807 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 421 +fn c359_l421_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c359_l421_action_invoke"); + let result = instance.call("ge_u", &[Value::I64(9223372036854775807 as i64), Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l35_action_invoke(&mut instance); + c2_l36_action_invoke(&mut instance); + c3_l37_action_invoke(&mut instance); + c4_l38_action_invoke(&mut instance); + c5_l39_action_invoke(&mut instance); + c6_l40_action_invoke(&mut instance); + c7_l41_action_invoke(&mut instance); + c8_l42_action_invoke(&mut instance); + c9_l44_action_invoke(&mut instance); + c10_l45_action_invoke(&mut instance); + c11_l46_action_invoke(&mut instance); + c12_l47_action_invoke(&mut instance); + c13_l48_action_invoke(&mut instance); + c14_l49_action_invoke(&mut instance); + c15_l50_action_invoke(&mut instance); + c16_l52_action_invoke(&mut instance); + c17_l53_action_invoke(&mut instance); + c18_l54_action_invoke(&mut instance); + c19_l55_action_invoke(&mut instance); + c20_l56_action_invoke(&mut instance); + c21_l57_action_invoke(&mut instance); + c22_l58_action_invoke(&mut instance); + c23_l59_action_invoke(&mut instance); + c24_l60_action_invoke(&mut instance); + c28_l65_action_invoke(&mut instance); + c29_l66_action_invoke(&mut instance); + c30_l67_action_invoke(&mut instance); + c31_l68_action_invoke(&mut instance); + c32_l69_action_invoke(&mut instance); + c33_l70_action_invoke(&mut instance); + c34_l71_action_invoke(&mut instance); + c35_l72_action_invoke(&mut instance); + c36_l73_action_invoke(&mut instance); + c37_l74_action_invoke(&mut instance); + c38_l75_action_invoke(&mut instance); + c39_l76_action_invoke(&mut instance); + c40_l77_action_invoke(&mut instance); + c41_l78_action_invoke(&mut instance); + c42_l79_action_invoke(&mut instance); + c43_l80_action_invoke(&mut instance); + c46_l84_action_invoke(&mut instance); + c47_l85_action_invoke(&mut instance); + c48_l86_action_invoke(&mut instance); + c49_l87_action_invoke(&mut instance); + c50_l88_action_invoke(&mut instance); + c51_l89_action_invoke(&mut instance); + c52_l90_action_invoke(&mut instance); + c53_l91_action_invoke(&mut instance); + c54_l92_action_invoke(&mut instance); + c55_l93_action_invoke(&mut instance); + c56_l94_action_invoke(&mut instance); + c57_l95_action_invoke(&mut instance); + c58_l96_action_invoke(&mut instance); + c59_l97_action_invoke(&mut instance); + c62_l101_action_invoke(&mut instance); + c63_l102_action_invoke(&mut instance); + c64_l103_action_invoke(&mut instance); + c65_l104_action_invoke(&mut instance); + c66_l105_action_invoke(&mut instance); + c67_l106_action_invoke(&mut instance); + c68_l107_action_invoke(&mut instance); + c69_l108_action_invoke(&mut instance); + c70_l109_action_invoke(&mut instance); + c71_l110_action_invoke(&mut instance); + c72_l111_action_invoke(&mut instance); + c73_l112_action_invoke(&mut instance); + c74_l113_action_invoke(&mut instance); + c75_l114_action_invoke(&mut instance); + c76_l115_action_invoke(&mut instance); + c77_l116_action_invoke(&mut instance); + c78_l117_action_invoke(&mut instance); + c79_l118_action_invoke(&mut instance); + c82_l122_action_invoke(&mut instance); + c83_l123_action_invoke(&mut instance); + c84_l124_action_invoke(&mut instance); + c85_l125_action_invoke(&mut instance); + c86_l126_action_invoke(&mut instance); + c87_l127_action_invoke(&mut instance); + c88_l128_action_invoke(&mut instance); + c89_l129_action_invoke(&mut instance); + c90_l130_action_invoke(&mut instance); + c91_l131_action_invoke(&mut instance); + c92_l132_action_invoke(&mut instance); + c93_l133_action_invoke(&mut instance); + c94_l134_action_invoke(&mut instance); + c95_l135_action_invoke(&mut instance); + c96_l137_action_invoke(&mut instance); + c97_l138_action_invoke(&mut instance); + c98_l139_action_invoke(&mut instance); + c99_l140_action_invoke(&mut instance); + c100_l141_action_invoke(&mut instance); + c101_l142_action_invoke(&mut instance); + c102_l143_action_invoke(&mut instance); + c103_l144_action_invoke(&mut instance); + c104_l146_action_invoke(&mut instance); + c105_l147_action_invoke(&mut instance); + c106_l148_action_invoke(&mut instance); + c107_l149_action_invoke(&mut instance); + c108_l150_action_invoke(&mut instance); + c109_l151_action_invoke(&mut instance); + c110_l152_action_invoke(&mut instance); + c111_l153_action_invoke(&mut instance); + c112_l155_action_invoke(&mut instance); + c113_l156_action_invoke(&mut instance); + c114_l157_action_invoke(&mut instance); + c115_l158_action_invoke(&mut instance); + c116_l159_action_invoke(&mut instance); + c117_l160_action_invoke(&mut instance); + c118_l161_action_invoke(&mut instance); + c119_l162_action_invoke(&mut instance); + c120_l163_action_invoke(&mut instance); + c121_l164_action_invoke(&mut instance); + c122_l166_action_invoke(&mut instance); + c123_l167_action_invoke(&mut instance); + c124_l168_action_invoke(&mut instance); + c125_l169_action_invoke(&mut instance); + c126_l170_action_invoke(&mut instance); + c127_l171_action_invoke(&mut instance); + c128_l172_action_invoke(&mut instance); + c129_l173_action_invoke(&mut instance); + c130_l174_action_invoke(&mut instance); + c131_l175_action_invoke(&mut instance); + c132_l176_action_invoke(&mut instance); + c133_l178_action_invoke(&mut instance); + c134_l179_action_invoke(&mut instance); + c135_l180_action_invoke(&mut instance); + c136_l181_action_invoke(&mut instance); + c137_l182_action_invoke(&mut instance); + c138_l183_action_invoke(&mut instance); + c139_l184_action_invoke(&mut instance); + c140_l185_action_invoke(&mut instance); + c141_l186_action_invoke(&mut instance); + c142_l187_action_invoke(&mut instance); + c143_l188_action_invoke(&mut instance); + c144_l189_action_invoke(&mut instance); + c145_l190_action_invoke(&mut instance); + c146_l191_action_invoke(&mut instance); + c147_l192_action_invoke(&mut instance); + c148_l193_action_invoke(&mut instance); + c149_l194_action_invoke(&mut instance); + c150_l196_action_invoke(&mut instance); + c151_l197_action_invoke(&mut instance); + c152_l198_action_invoke(&mut instance); + c153_l199_action_invoke(&mut instance); + c154_l200_action_invoke(&mut instance); + c155_l201_action_invoke(&mut instance); + c156_l202_action_invoke(&mut instance); + c157_l203_action_invoke(&mut instance); + c158_l204_action_invoke(&mut instance); + c159_l205_action_invoke(&mut instance); + c160_l206_action_invoke(&mut instance); + c161_l207_action_invoke(&mut instance); + c162_l208_action_invoke(&mut instance); + c163_l209_action_invoke(&mut instance); + c164_l210_action_invoke(&mut instance); + c165_l211_action_invoke(&mut instance); + c166_l212_action_invoke(&mut instance); + c167_l214_action_invoke(&mut instance); + c168_l215_action_invoke(&mut instance); + c169_l216_action_invoke(&mut instance); + c170_l217_action_invoke(&mut instance); + c171_l218_action_invoke(&mut instance); + c172_l219_action_invoke(&mut instance); + c173_l220_action_invoke(&mut instance); + c174_l221_action_invoke(&mut instance); + c175_l222_action_invoke(&mut instance); + c176_l223_action_invoke(&mut instance); + c177_l224_action_invoke(&mut instance); + c178_l225_action_invoke(&mut instance); + c179_l226_action_invoke(&mut instance); + c180_l228_action_invoke(&mut instance); + c181_l229_action_invoke(&mut instance); + c182_l230_action_invoke(&mut instance); + c183_l231_action_invoke(&mut instance); + c184_l232_action_invoke(&mut instance); + c185_l233_action_invoke(&mut instance); + c186_l234_action_invoke(&mut instance); + c187_l235_action_invoke(&mut instance); + c188_l236_action_invoke(&mut instance); + c189_l237_action_invoke(&mut instance); + c190_l238_action_invoke(&mut instance); + c191_l239_action_invoke(&mut instance); + c192_l240_action_invoke(&mut instance); + c193_l242_action_invoke(&mut instance); + c194_l243_action_invoke(&mut instance); + c195_l244_action_invoke(&mut instance); + c196_l245_action_invoke(&mut instance); + c197_l246_action_invoke(&mut instance); + c198_l247_action_invoke(&mut instance); + c199_l248_action_invoke(&mut instance); + c200_l249_action_invoke(&mut instance); + c201_l251_action_invoke(&mut instance); + c202_l252_action_invoke(&mut instance); + c203_l253_action_invoke(&mut instance); + c204_l254_action_invoke(&mut instance); + c205_l255_action_invoke(&mut instance); + c206_l256_action_invoke(&mut instance); + c207_l258_action_invoke(&mut instance); + c208_l259_action_invoke(&mut instance); + c209_l260_action_invoke(&mut instance); + c210_l261_action_invoke(&mut instance); + c211_l262_action_invoke(&mut instance); + c212_l263_action_invoke(&mut instance); + c213_l264_action_invoke(&mut instance); + c214_l265_action_invoke(&mut instance); + c215_l267_action_invoke(&mut instance); + c216_l268_action_invoke(&mut instance); + c217_l269_action_invoke(&mut instance); + c218_l270_action_invoke(&mut instance); + c219_l271_action_invoke(&mut instance); + c220_l273_action_invoke(&mut instance); + c221_l274_action_invoke(&mut instance); + c222_l275_action_invoke(&mut instance); + c223_l276_action_invoke(&mut instance); + c224_l277_action_invoke(&mut instance); + c225_l278_action_invoke(&mut instance); + c226_l279_action_invoke(&mut instance); + c227_l280_action_invoke(&mut instance); + c228_l281_action_invoke(&mut instance); + c229_l282_action_invoke(&mut instance); + c230_l283_action_invoke(&mut instance); + c231_l284_action_invoke(&mut instance); + c232_l285_action_invoke(&mut instance); + c233_l286_action_invoke(&mut instance); + c234_l288_action_invoke(&mut instance); + c235_l289_action_invoke(&mut instance); + c236_l290_action_invoke(&mut instance); + c237_l291_action_invoke(&mut instance); + c238_l292_action_invoke(&mut instance); + c239_l293_action_invoke(&mut instance); + c240_l294_action_invoke(&mut instance); + c241_l295_action_invoke(&mut instance); + c242_l296_action_invoke(&mut instance); + c243_l297_action_invoke(&mut instance); + c244_l298_action_invoke(&mut instance); + c245_l299_action_invoke(&mut instance); + c246_l300_action_invoke(&mut instance); + c247_l301_action_invoke(&mut instance); + c248_l303_action_invoke(&mut instance); + c249_l304_action_invoke(&mut instance); + c250_l305_action_invoke(&mut instance); + c251_l306_action_invoke(&mut instance); + c252_l307_action_invoke(&mut instance); + c253_l308_action_invoke(&mut instance); + c254_l309_action_invoke(&mut instance); + c255_l310_action_invoke(&mut instance); + c256_l311_action_invoke(&mut instance); + c257_l312_action_invoke(&mut instance); + c258_l313_action_invoke(&mut instance); + c259_l314_action_invoke(&mut instance); + c260_l315_action_invoke(&mut instance); + c261_l316_action_invoke(&mut instance); + c262_l318_action_invoke(&mut instance); + c263_l319_action_invoke(&mut instance); + c264_l320_action_invoke(&mut instance); + c265_l321_action_invoke(&mut instance); + c266_l322_action_invoke(&mut instance); + c267_l323_action_invoke(&mut instance); + c268_l324_action_invoke(&mut instance); + c269_l325_action_invoke(&mut instance); + c270_l326_action_invoke(&mut instance); + c271_l327_action_invoke(&mut instance); + c272_l328_action_invoke(&mut instance); + c273_l329_action_invoke(&mut instance); + c274_l330_action_invoke(&mut instance); + c275_l331_action_invoke(&mut instance); + c276_l333_action_invoke(&mut instance); + c277_l334_action_invoke(&mut instance); + c278_l335_action_invoke(&mut instance); + c279_l336_action_invoke(&mut instance); + c280_l337_action_invoke(&mut instance); + c281_l338_action_invoke(&mut instance); + c282_l339_action_invoke(&mut instance); + c283_l340_action_invoke(&mut instance); + c284_l341_action_invoke(&mut instance); + c285_l342_action_invoke(&mut instance); + c286_l343_action_invoke(&mut instance); + c287_l344_action_invoke(&mut instance); + c288_l345_action_invoke(&mut instance); + c289_l346_action_invoke(&mut instance); + c290_l348_action_invoke(&mut instance); + c291_l349_action_invoke(&mut instance); + c292_l350_action_invoke(&mut instance); + c293_l351_action_invoke(&mut instance); + c294_l352_action_invoke(&mut instance); + c295_l353_action_invoke(&mut instance); + c296_l354_action_invoke(&mut instance); + c297_l355_action_invoke(&mut instance); + c298_l356_action_invoke(&mut instance); + c299_l357_action_invoke(&mut instance); + c300_l358_action_invoke(&mut instance); + c301_l359_action_invoke(&mut instance); + c302_l360_action_invoke(&mut instance); + c303_l361_action_invoke(&mut instance); + c304_l363_action_invoke(&mut instance); + c305_l364_action_invoke(&mut instance); + c306_l365_action_invoke(&mut instance); + c307_l366_action_invoke(&mut instance); + c308_l367_action_invoke(&mut instance); + c309_l368_action_invoke(&mut instance); + c310_l369_action_invoke(&mut instance); + c311_l370_action_invoke(&mut instance); + c312_l371_action_invoke(&mut instance); + c313_l372_action_invoke(&mut instance); + c314_l373_action_invoke(&mut instance); + c315_l374_action_invoke(&mut instance); + c316_l375_action_invoke(&mut instance); + c317_l376_action_invoke(&mut instance); + c318_l378_action_invoke(&mut instance); + c319_l379_action_invoke(&mut instance); + c320_l380_action_invoke(&mut instance); + c321_l381_action_invoke(&mut instance); + c322_l382_action_invoke(&mut instance); + c323_l383_action_invoke(&mut instance); + c324_l384_action_invoke(&mut instance); + c325_l385_action_invoke(&mut instance); + c326_l386_action_invoke(&mut instance); + c327_l387_action_invoke(&mut instance); + c328_l388_action_invoke(&mut instance); + c329_l389_action_invoke(&mut instance); + c330_l390_action_invoke(&mut instance); + c331_l391_action_invoke(&mut instance); + c332_l393_action_invoke(&mut instance); + c333_l394_action_invoke(&mut instance); + c334_l395_action_invoke(&mut instance); + c335_l396_action_invoke(&mut instance); + c336_l397_action_invoke(&mut instance); + c337_l398_action_invoke(&mut instance); + c338_l399_action_invoke(&mut instance); + c339_l400_action_invoke(&mut instance); + c340_l401_action_invoke(&mut instance); + c341_l402_action_invoke(&mut instance); + c342_l403_action_invoke(&mut instance); + c343_l404_action_invoke(&mut instance); + c344_l405_action_invoke(&mut instance); + c345_l406_action_invoke(&mut instance); + c346_l408_action_invoke(&mut instance); + c347_l409_action_invoke(&mut instance); + c348_l410_action_invoke(&mut instance); + c349_l411_action_invoke(&mut instance); + c350_l412_action_invoke(&mut instance); + c351_l413_action_invoke(&mut instance); + c352_l414_action_invoke(&mut instance); + c353_l415_action_invoke(&mut instance); + c354_l416_action_invoke(&mut instance); + c355_l417_action_invoke(&mut instance); + c356_l418_action_invoke(&mut instance); + c357_l419_action_invoke(&mut instance); + c358_l420_action_invoke(&mut instance); + c359_l421_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/if_.rs b/lib/runtime/tests/spectests/if_.rs new file mode 100644 index 000000000..e9f1ee10d --- /dev/null +++ b/lib/runtime/tests/spectests/if_.rs @@ -0,0 +1,1808 @@ +// 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/if_.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 3 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func (param i32 i32) (result i32))) + (type (;1;) (func)) + (type (;2;) (func (param i32))) + (type (;3;) (func (param i32) (result i32))) + (type (;4;) (func (result i32))) + (func (;0;) (type 1)) + (func (;1;) (type 2) (param i32) + get_local 0 + if ;; label = @1 + end + get_local 0 + if ;; label = @1 + end + get_local 0 + if ;; label = @1 + end + get_local 0 + if ;; label = @1 + end) + (func (;2;) (type 3) (param i32) (result i32) + get_local 0 + if ;; label = @1 + nop + end + get_local 0 + if ;; label = @1 + nop + else + nop + end + get_local 0 + if (result i32) ;; label = @1 + i32.const 7 + else + i32.const 8 + end) + (func (;3;) (type 3) (param i32) (result i32) + get_local 0 + if ;; label = @1 + call 0 + call 0 + call 0 + end + get_local 0 + if ;; label = @1 + else + call 0 + call 0 + call 0 + end + get_local 0 + if (result i32) ;; label = @1 + call 0 + call 0 + i32.const 8 + else + call 0 + call 0 + i32.const 9 + end) + (func (;4;) (type 0) (param i32 i32) (result i32) + get_local 0 + if (result i32) ;; label = @1 + get_local 1 + if ;; label = @2 + call 0 + block ;; label = @3 + end + nop + end + get_local 1 + if ;; label = @2 + else + call 0 + block ;; label = @3 + end + nop + end + get_local 1 + if (result i32) ;; label = @2 + call 0 + i32.const 9 + else + call 0 + i32.const 10 + end + else + get_local 1 + if ;; label = @2 + call 0 + block ;; label = @3 + end + nop + end + get_local 1 + if ;; label = @2 + else + call 0 + block ;; label = @3 + end + nop + end + get_local 1 + if (result i32) ;; label = @2 + call 0 + i32.const 10 + else + call 0 + i32.const 11 + end + end) + (func (;5;) (type 3) (param i32) (result i32) + get_local 0 + if (result i32) ;; label = @1 + call 0 + i32.const 1 + else + call 0 + i32.const 0 + end + i32.const 2 + i32.const 3 + select) + (func (;6;) (type 3) (param i32) (result i32) + i32.const 2 + get_local 0 + if (result i32) ;; label = @1 + call 0 + i32.const 1 + else + call 0 + i32.const 0 + end + i32.const 3 + select) + (func (;7;) (type 3) (param i32) (result i32) + i32.const 2 + i32.const 3 + get_local 0 + if (result i32) ;; label = @1 + call 0 + i32.const 1 + else + call 0 + i32.const 0 + end + select) + (func (;8;) (type 3) (param i32) (result i32) + loop (result i32) ;; label = @1 + get_local 0 + if (result i32) ;; label = @2 + call 0 + i32.const 1 + else + call 0 + i32.const 0 + end + call 0 + call 0 + end) + (func (;9;) (type 3) (param i32) (result i32) + loop (result i32) ;; label = @1 + call 0 + get_local 0 + if (result i32) ;; label = @2 + call 0 + i32.const 1 + else + call 0 + i32.const 0 + end + call 0 + end) + (func (;10;) (type 3) (param i32) (result i32) + loop (result i32) ;; label = @1 + call 0 + call 0 + get_local 0 + if (result i32) ;; label = @2 + call 0 + i32.const 1 + else + call 0 + i32.const 0 + end + end) + (func (;11;) (type 3) (param i32) (result i32) + get_local 0 + if (result i32) ;; label = @1 + i32.const 1 + else + i32.const 0 + end + if (result i32) ;; label = @1 + call 0 + i32.const 2 + else + call 0 + i32.const 3 + end) + (func (;12;) (type 3) (param i32) (result i32) + block (result i32) ;; label = @1 + get_local 0 + if (result i32) ;; label = @2 + call 0 + i32.const 1 + else + call 0 + i32.const 0 + end + i32.const 2 + br_if 0 (;@1;) + i32.const 3 + return + end) + (func (;13;) (type 3) (param i32) (result i32) + block (result i32) ;; label = @1 + i32.const 2 + get_local 0 + if (result i32) ;; label = @2 + call 0 + i32.const 1 + else + call 0 + i32.const 0 + end + br_if 0 (;@1;) + i32.const 3 + return + end) + (func (;14;) (type 3) (param i32) (result i32) + block (result i32) ;; label = @1 + get_local 0 + if (result i32) ;; label = @2 + call 0 + i32.const 1 + else + call 0 + i32.const 0 + end + i32.const 2 + br_table 0 (;@1;) 0 (;@1;) + end) + (func (;15;) (type 3) (param i32) (result i32) + block (result i32) ;; label = @1 + i32.const 2 + get_local 0 + if (result i32) ;; label = @2 + call 0 + i32.const 1 + else + call 0 + i32.const 0 + end + br_table 0 (;@1;) 0 (;@1;) + end) + (func (;16;) (type 0) (param i32 i32) (result i32) + get_local 0) + (func (;17;) (type 3) (param i32) (result i32) + block (result i32) ;; label = @1 + get_local 0 + if (result i32) ;; label = @2 + call 0 + i32.const 1 + else + call 0 + i32.const 0 + end + i32.const 2 + i32.const 0 + call_indirect (type 0) + end) + (func (;18;) (type 3) (param i32) (result i32) + block (result i32) ;; label = @1 + i32.const 2 + get_local 0 + if (result i32) ;; label = @2 + call 0 + i32.const 1 + else + call 0 + i32.const 0 + end + i32.const 0 + call_indirect (type 0) + end) + (func (;19;) (type 3) (param i32) (result i32) + block (result i32) ;; label = @1 + i32.const 2 + i32.const 0 + get_local 0 + if (result i32) ;; label = @2 + call 0 + i32.const 1 + else + call 0 + i32.const 0 + end + call_indirect (type 0) + end) + (func (;20;) (type 2) (param i32) + get_local 0 + if (result i32) ;; label = @1 + call 0 + i32.const 1 + else + call 0 + i32.const 0 + end + i32.const 2 + i32.store) + (func (;21;) (type 2) (param i32) + i32.const 2 + get_local 0 + if (result i32) ;; label = @1 + call 0 + i32.const 1 + else + call 0 + i32.const 0 + end + i32.store) + (func (;22;) (type 3) (param i32) (result i32) + get_local 0 + if (result i32) ;; label = @1 + i32.const 1 + else + i32.const 0 + end + memory.grow) + (func (;23;) (type 3) (param i32) (result i32) + get_local 0) + (func (;24;) (type 3) (param i32) (result i32) + get_local 0 + if (result i32) ;; label = @1 + i32.const 1 + else + i32.const 0 + end + call 23) + (func (;25;) (type 3) (param i32) (result i32) + get_local 0 + if (result i32) ;; label = @1 + i32.const 1 + else + i32.const 0 + end + return) + (func (;26;) (type 2) (param i32) + get_local 0 + if (result i32) ;; label = @1 + i32.const 1 + else + i32.const 0 + end + drop) + (func (;27;) (type 3) (param i32) (result i32) + block (result i32) ;; label = @1 + get_local 0 + if (result i32) ;; label = @2 + i32.const 1 + else + i32.const 0 + end + br 0 (;@1;) + end) + (func (;28;) (type 3) (param i32) (result i32) + (local i32) + get_local 0 + if (result i32) ;; label = @1 + i32.const 1 + else + i32.const 0 + end + set_local 0 + get_local 0) + (func (;29;) (type 3) (param i32) (result i32) + get_local 0 + if (result i32) ;; label = @1 + i32.const 1 + else + i32.const 0 + end + tee_local 0) + (func (;30;) (type 3) (param i32) (result i32) + get_local 0 + if (result i32) ;; label = @1 + i32.const 1 + else + i32.const 0 + end + set_global 0 + get_global 0) + (func (;31;) (type 3) (param i32) (result i32) + get_local 0 + if (result i32) ;; label = @1 + i32.const 11 + else + i32.const 10 + end + i32.load) + (func (;32;) (type 3) (param i32) (result i32) + get_local 0 + if (result i32) ;; label = @1 + call 0 + i32.const 13 + else + call 0 + i32.const -13 + end + i32.ctz) + (func (;33;) (type 0) (param i32 i32) (result i32) + get_local 0 + if (result i32) ;; label = @1 + call 0 + i32.const 3 + else + call 0 + i32.const -3 + end + get_local 1 + if (result i32) ;; label = @1 + call 0 + i32.const 4 + else + call 0 + i32.const -5 + end + i32.mul) + (func (;34;) (type 3) (param i32) (result i32) + get_local 0 + if (result i32) ;; label = @1 + call 0 + i32.const 13 + else + call 0 + i32.const 0 + end + i32.eqz) + (func (;35;) (type 0) (param i32 i32) (result i32) + get_local 0 + if (result f32) ;; label = @1 + call 0 + f32.const 0x1.8p+1 (;=3;) + else + call 0 + f32.const -0x1.8p+1 (;=-3;) + end + get_local 1 + if (result f32) ;; label = @1 + call 0 + f32.const 0x1p+2 (;=4;) + else + call 0 + f32.const -0x1p+2 (;=-4;) + end + f32.gt) + (func (;36;) (type 4) (result i32) + i32.const 1 + if ;; label = @1 + br 0 (;@1;) + unreachable + end + i32.const 1 + if ;; label = @1 + br 0 (;@1;) + unreachable + else + unreachable + end + i32.const 0 + if ;; label = @1 + unreachable + else + br 0 (;@1;) + unreachable + end + i32.const 1 + if ;; label = @1 + i32.const 1 + br_if 0 (;@1;) + unreachable + end + i32.const 1 + if ;; label = @1 + i32.const 1 + br_if 0 (;@1;) + unreachable + else + unreachable + end + i32.const 0 + if ;; label = @1 + unreachable + else + i32.const 1 + br_if 0 (;@1;) + unreachable + end + i32.const 1 + if ;; label = @1 + i32.const 0 + br_table 0 (;@1;) + unreachable + end + i32.const 1 + if ;; label = @1 + i32.const 0 + br_table 0 (;@1;) + unreachable + else + unreachable + end + i32.const 0 + if ;; label = @1 + unreachable + else + i32.const 0 + br_table 0 (;@1;) + unreachable + end + i32.const 19) + (func (;37;) (type 3) (param i32) (result i32) + get_local 0 + if (result i32) ;; label = @1 + i32.const 18 + br 0 (;@1;) + i32.const 19 + else + i32.const 21 + br 0 (;@1;) + i32.const 20 + end) + (func (;38;) (type 3) (param i32) (result i32) + (local i32) + block (result i32) ;; label = @1 + i32.const 1 + set_local 1 + get_local 0 + end + if ;; label = @1 + get_local 1 + i32.const 3 + i32.mul + set_local 1 + get_local 1 + i32.const 5 + i32.sub + set_local 1 + get_local 1 + i32.const 7 + i32.mul + set_local 1 + br 0 (;@1;) + get_local 1 + i32.const 100 + i32.mul + set_local 1 + else + get_local 1 + i32.const 5 + i32.mul + set_local 1 + get_local 1 + i32.const 7 + i32.sub + set_local 1 + get_local 1 + i32.const 3 + i32.mul + set_local 1 + br 0 (;@1;) + get_local 1 + i32.const 1000 + i32.mul + set_local 1 + end + get_local 1) + (table (;0;) 1 1 anyfunc) + (memory (;0;) 1) + (global (;0;) (mut i32) (i32.const 10)) + (export \"empty\" (func 1)) + (export \"singular\" (func 2)) + (export \"multi\" (func 3)) + (export \"nested\" (func 4)) + (export \"as-select-first\" (func 5)) + (export \"as-select-mid\" (func 6)) + (export \"as-select-last\" (func 7)) + (export \"as-loop-first\" (func 8)) + (export \"as-loop-mid\" (func 9)) + (export \"as-loop-last\" (func 10)) + (export \"as-if-condition\" (func 11)) + (export \"as-br_if-first\" (func 12)) + (export \"as-br_if-last\" (func 13)) + (export \"as-br_table-first\" (func 14)) + (export \"as-br_table-last\" (func 15)) + (export \"as-call_indirect-first\" (func 17)) + (export \"as-call_indirect-mid\" (func 18)) + (export \"as-call_indirect-last\" (func 19)) + (export \"as-store-first\" (func 20)) + (export \"as-store-last\" (func 21)) + (export \"as-memory.grow-value\" (func 22)) + (export \"as-call-value\" (func 24)) + (export \"as-return-value\" (func 25)) + (export \"as-drop-operand\" (func 26)) + (export \"as-br-value\" (func 27)) + (export \"as-set_local-value\" (func 28)) + (export \"as-tee_local-value\" (func 29)) + (export \"as-set_global-value\" (func 30)) + (export \"as-load-operand\" (func 31)) + (export \"as-unary-operand\" (func 32)) + (export \"as-binary-operand\" (func 33)) + (export \"as-test-operand\" (func 34)) + (export \"as-compare-operand\" (func 35)) + (export \"break-bare\" (func 36)) + (export \"break-value\" (func 37)) + (export \"effects\" (func 38)) + (elem (;0;) (i32.const 0) 16)) + "; + 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 384 +fn c1_l384_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l384_action_invoke"); + let result = instance.call("empty", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 385 +fn c2_l385_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l385_action_invoke"); + let result = instance.call("empty", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 386 +fn c3_l386_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l386_action_invoke"); + let result = instance.call("empty", &[Value::I32(100 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 387 +fn c4_l387_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l387_action_invoke"); + let result = instance.call("empty", &[Value::I32(-2 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 389 +fn c5_l389_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l389_action_invoke"); + let result = instance.call("singular", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(8 as i32)))); + result.map(|_| ()) +} + +// Line 390 +fn c6_l390_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l390_action_invoke"); + let result = instance.call("singular", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(7 as i32)))); + result.map(|_| ()) +} + +// Line 391 +fn c7_l391_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l391_action_invoke"); + let result = instance.call("singular", &[Value::I32(10 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(7 as i32)))); + result.map(|_| ()) +} + +// Line 392 +fn c8_l392_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l392_action_invoke"); + let result = instance.call("singular", &[Value::I32(-10 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(7 as i32)))); + result.map(|_| ()) +} + +// Line 394 +fn c9_l394_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l394_action_invoke"); + let result = instance.call("multi", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 395 +fn c10_l395_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c10_l395_action_invoke"); + let result = instance.call("multi", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(8 as i32)))); + result.map(|_| ()) +} + +// Line 396 +fn c11_l396_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c11_l396_action_invoke"); + let result = instance.call("multi", &[Value::I32(13 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(8 as i32)))); + result.map(|_| ()) +} + +// Line 397 +fn c12_l397_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c12_l397_action_invoke"); + let result = instance.call("multi", &[Value::I32(-5 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(8 as i32)))); + result.map(|_| ()) +} + +// Line 399 +fn c13_l399_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c13_l399_action_invoke"); + let result = instance.call("nested", &[Value::I32(0 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(11 as i32)))); + result.map(|_| ()) +} + +// Line 400 +fn c14_l400_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c14_l400_action_invoke"); + let result = instance.call("nested", &[Value::I32(1 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); + result.map(|_| ()) +} + +// Line 401 +fn c15_l401_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c15_l401_action_invoke"); + let result = instance.call("nested", &[Value::I32(0 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); + result.map(|_| ()) +} + +// Line 402 +fn c16_l402_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c16_l402_action_invoke"); + let result = instance.call("nested", &[Value::I32(3 as i32), Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 403 +fn c17_l403_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c17_l403_action_invoke"); + let result = instance.call("nested", &[Value::I32(0 as i32), Value::I32(-100 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); + result.map(|_| ()) +} + +// Line 404 +fn c18_l404_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c18_l404_action_invoke"); + let result = instance.call("nested", &[Value::I32(10 as i32), Value::I32(10 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 405 +fn c19_l405_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c19_l405_action_invoke"); + let result = instance.call("nested", &[Value::I32(0 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); + result.map(|_| ()) +} + +// Line 406 +fn c20_l406_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c20_l406_action_invoke"); + let result = instance.call("nested", &[Value::I32(-111 as i32), Value::I32(-2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 408 +fn c21_l408_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c21_l408_action_invoke"); + let result = instance.call("as-select-first", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 409 +fn c22_l409_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c22_l409_action_invoke"); + let result = instance.call("as-select-first", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 410 +fn c23_l410_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c23_l410_action_invoke"); + let result = instance.call("as-select-mid", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 411 +fn c24_l411_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c24_l411_action_invoke"); + let result = instance.call("as-select-mid", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 412 +fn c25_l412_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c25_l412_action_invoke"); + let result = instance.call("as-select-last", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 413 +fn c26_l413_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c26_l413_action_invoke"); + let result = instance.call("as-select-last", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 415 +fn c27_l415_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c27_l415_action_invoke"); + let result = instance.call("as-loop-first", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 416 +fn c28_l416_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c28_l416_action_invoke"); + let result = instance.call("as-loop-first", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 417 +fn c29_l417_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c29_l417_action_invoke"); + let result = instance.call("as-loop-mid", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 418 +fn c30_l418_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c30_l418_action_invoke"); + let result = instance.call("as-loop-mid", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 419 +fn c31_l419_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c31_l419_action_invoke"); + let result = instance.call("as-loop-last", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 420 +fn c32_l420_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c32_l420_action_invoke"); + let result = instance.call("as-loop-last", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 422 +fn c33_l422_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c33_l422_action_invoke"); + let result = instance.call("as-if-condition", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 423 +fn c34_l423_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c34_l423_action_invoke"); + let result = instance.call("as-if-condition", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 425 +fn c35_l425_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c35_l425_action_invoke"); + let result = instance.call("as-br_if-first", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 426 +fn c36_l426_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c36_l426_action_invoke"); + let result = instance.call("as-br_if-first", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 427 +fn c37_l427_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c37_l427_action_invoke"); + let result = instance.call("as-br_if-last", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 428 +fn c38_l428_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c38_l428_action_invoke"); + let result = instance.call("as-br_if-last", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 430 +fn c39_l430_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c39_l430_action_invoke"); + let result = instance.call("as-br_table-first", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 431 +fn c40_l431_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c40_l431_action_invoke"); + let result = instance.call("as-br_table-first", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 432 +fn c41_l432_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c41_l432_action_invoke"); + let result = instance.call("as-br_table-last", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 433 +fn c42_l433_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c42_l433_action_invoke"); + let result = instance.call("as-br_table-last", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 435 +fn c43_l435_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c43_l435_action_invoke"); + let result = instance.call("as-call_indirect-first", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 436 +fn c44_l436_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c44_l436_action_invoke"); + let result = instance.call("as-call_indirect-first", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 437 +fn c45_l437_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c45_l437_action_invoke"); + let result = instance.call("as-call_indirect-mid", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 438 +fn c46_l438_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c46_l438_action_invoke"); + let result = instance.call("as-call_indirect-mid", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 439 +fn c47_l439_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c47_l439_action_invoke"); + let result = instance.call("as-call_indirect-last", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 440 +fn c48_l440_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c48_l440_action_invoke"); + let result = instance.call("as-call_indirect-last", &[Value::I32(1 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c48_l440_assert_trap() { + let mut instance = create_module_1(); + let result = c48_l440_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 442 +fn c49_l442_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c49_l442_action_invoke"); + let result = instance.call("as-store-first", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 443 +fn c50_l443_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c50_l443_action_invoke"); + let result = instance.call("as-store-first", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 444 +fn c51_l444_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c51_l444_action_invoke"); + let result = instance.call("as-store-last", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 445 +fn c52_l445_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c52_l445_action_invoke"); + let result = instance.call("as-store-last", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 447 +fn c53_l447_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c53_l447_action_invoke"); + let result = instance.call("as-memory.grow-value", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 448 +fn c54_l448_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c54_l448_action_invoke"); + let result = instance.call("as-memory.grow-value", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 450 +fn c55_l450_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c55_l450_action_invoke"); + let result = instance.call("as-call-value", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 451 +fn c56_l451_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c56_l451_action_invoke"); + let result = instance.call("as-call-value", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 453 +fn c57_l453_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c57_l453_action_invoke"); + let result = instance.call("as-return-value", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 454 +fn c58_l454_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c58_l454_action_invoke"); + let result = instance.call("as-return-value", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 456 +fn c59_l456_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c59_l456_action_invoke"); + let result = instance.call("as-drop-operand", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 457 +fn c60_l457_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c60_l457_action_invoke"); + let result = instance.call("as-drop-operand", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 459 +fn c61_l459_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c61_l459_action_invoke"); + let result = instance.call("as-br-value", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 460 +fn c62_l460_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c62_l460_action_invoke"); + let result = instance.call("as-br-value", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 462 +fn c63_l462_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c63_l462_action_invoke"); + let result = instance.call("as-set_local-value", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 463 +fn c64_l463_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c64_l463_action_invoke"); + let result = instance.call("as-set_local-value", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 465 +fn c65_l465_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c65_l465_action_invoke"); + let result = instance.call("as-tee_local-value", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 466 +fn c66_l466_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c66_l466_action_invoke"); + let result = instance.call("as-tee_local-value", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 468 +fn c67_l468_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c67_l468_action_invoke"); + let result = instance.call("as-set_global-value", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 469 +fn c68_l469_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c68_l469_action_invoke"); + let result = instance.call("as-set_global-value", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 471 +fn c69_l471_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c69_l471_action_invoke"); + let result = instance.call("as-load-operand", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 472 +fn c70_l472_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c70_l472_action_invoke"); + let result = instance.call("as-load-operand", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 474 +fn c71_l474_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c71_l474_action_invoke"); + let result = instance.call("as-unary-operand", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 475 +fn c72_l475_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c72_l475_action_invoke"); + let result = instance.call("as-unary-operand", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 476 +fn c73_l476_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c73_l476_action_invoke"); + let result = instance.call("as-unary-operand", &[Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 478 +fn c74_l478_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c74_l478_action_invoke"); + let result = instance.call("as-binary-operand", &[Value::I32(0 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(15 as i32)))); + result.map(|_| ()) +} + +// Line 479 +fn c75_l479_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c75_l479_action_invoke"); + let result = instance.call("as-binary-operand", &[Value::I32(0 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-12 as i32)))); + result.map(|_| ()) +} + +// Line 480 +fn c76_l480_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c76_l480_action_invoke"); + let result = instance.call("as-binary-operand", &[Value::I32(1 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-15 as i32)))); + result.map(|_| ()) +} + +// Line 481 +fn c77_l481_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c77_l481_action_invoke"); + let result = instance.call("as-binary-operand", &[Value::I32(1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(12 as i32)))); + result.map(|_| ()) +} + +// Line 483 +fn c78_l483_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c78_l483_action_invoke"); + let result = instance.call("as-test-operand", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 484 +fn c79_l484_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c79_l484_action_invoke"); + let result = instance.call("as-test-operand", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 486 +fn c80_l486_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c80_l486_action_invoke"); + let result = instance.call("as-compare-operand", &[Value::I32(0 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 487 +fn c81_l487_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c81_l487_action_invoke"); + let result = instance.call("as-compare-operand", &[Value::I32(0 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 488 +fn c82_l488_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c82_l488_action_invoke"); + let result = instance.call("as-compare-operand", &[Value::I32(1 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 489 +fn c83_l489_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c83_l489_action_invoke"); + let result = instance.call("as-compare-operand", &[Value::I32(1 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 491 +fn c84_l491_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c84_l491_action_invoke"); + let result = instance.call("break-bare", &[]); + assert_eq!(result, Ok(Some(Value::I32(19 as i32)))); + result.map(|_| ()) +} + +// Line 492 +fn c85_l492_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c85_l492_action_invoke"); + let result = instance.call("break-value", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(18 as i32)))); + result.map(|_| ()) +} + +// Line 493 +fn c86_l493_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c86_l493_action_invoke"); + let result = instance.call("break-value", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(21 as i32)))); + result.map(|_| ()) +} + +// Line 495 +fn c87_l495_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c87_l495_action_invoke"); + let result = instance.call("effects", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-14 as i32)))); + result.map(|_| ()) +} + +// Line 496 +fn c88_l496_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c88_l496_action_invoke"); + let result = instance.call("effects", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-6 as i32)))); + result.map(|_| ()) +} + +// Line 499 +#[test] +fn c89_l499_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 0, 4, 64, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 503 +#[test] +fn c90_l503_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 0, 4, 64, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 507 +#[test] +fn c91_l507_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 0, 4, 64, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 511 +#[test] +fn c92_l511_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 0, 4, 64, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 516 +#[test] +fn c93_l516_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 0, 4, 64, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 520 +#[test] +fn c94_l520_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 0, 4, 64, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 524 +#[test] +fn c95_l524_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 0, 4, 64, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 528 +#[test] +fn c96_l528_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 0, 4, 64, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 533 +#[test] +fn c97_l533_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 11, 1, 9, 0, 65, 1, 4, 64, 65, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 539 +#[test] +fn c98_l539_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 11, 1, 9, 0, 65, 1, 4, 64, 65, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 545 +#[test] +fn c99_l545_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 1, 4, 64, 5, 65, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 551 +#[test] +fn c100_l551_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 14, 1, 12, 0, 65, 1, 4, 64, 65, 1, 5, 65, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 558 +#[test] +fn c101_l558_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 1, 4, 127, 5, 65, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 564 +#[test] +fn c102_l564_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 11, 1, 9, 0, 65, 1, 4, 127, 65, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 570 +#[test] +fn c103_l570_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 1, 4, 127, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 576 +#[test] +fn c104_l576_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 11, 1, 9, 0, 65, 1, 4, 127, 65, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 583 +#[test] +fn c105_l583_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 13, 1, 11, 0, 65, 1, 4, 127, 1, 5, 65, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 589 +#[test] +fn c106_l589_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 13, 1, 11, 0, 65, 1, 4, 127, 65, 0, 5, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 595 +#[test] +fn c107_l595_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 1, 4, 127, 1, 5, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 602 +#[test] +fn c108_l602_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 65, 1, 4, 127, 66, 1, 5, 65, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 608 +#[test] +fn c109_l608_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 65, 1, 4, 127, 65, 1, 5, 66, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 614 +#[test] +fn c110_l614_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 65, 1, 4, 127, 66, 1, 5, 66, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 620 +#[test] +fn c111_l620_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 21, 1, 19, 0, 65, 1, 4, 127, 66, 1, 5, 68, 0, 0, 0, 0, 0, 0, 240, 63, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 627 +#[test] +fn c112_l627_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 65, 0, 4, 126, 0, 0, 0, 27, 5, 66, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 637 +#[test] +fn c113_l637_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 65, 1, 4, 126, 66, 0, 5, 0, 0, 0, 27, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 647 +#[test] +fn c114_l647_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 18, 1, 16, 0, 65, 1, 4, 126, 0, 0, 0, 27, 5, 0, 0, 0, 27, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 658 +#[test] +fn c115_l658_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 65, 1, 4, 127, 12, 0, 5, 65, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 664 +#[test] +fn c116_l664_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 65, 1, 4, 127, 65, 1, 5, 12, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 670 +#[test] +fn c117_l670_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 65, 1, 4, 127, 12, 0, 65, 1, 5, 65, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 679 +#[test] +fn c118_l679_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 65, 1, 4, 127, 65, 1, 5, 12, 0, 65, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 688 +#[test] +fn c119_l688_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 17, 1, 15, 0, 65, 1, 4, 127, 1, 12, 0, 65, 1, 5, 65, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 697 +#[test] +fn c120_l697_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 17, 1, 15, 0, 65, 1, 4, 127, 65, 1, 5, 1, 12, 0, 65, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 707 +#[test] +fn c121_l707_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 18, 1, 16, 0, 65, 1, 4, 127, 66, 1, 12, 0, 65, 1, 5, 65, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 716 +#[test] +fn c122_l716_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 18, 1, 16, 0, 65, 1, 4, 127, 65, 1, 5, 66, 1, 12, 0, 65, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 727 +#[test] +fn c123_l727_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 105, 102, 32, 101, 110, 100, 32, 36, 108, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 731 +#[test] +fn c124_l731_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 105, 102, 32, 36, 97, 32, 101, 110, 100, 32, 36, 108, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 735 +#[test] +fn c125_l735_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 105, 102, 32, 101, 108, 115, 101, 32, 36, 108, 32, 101, 110, 100, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 739 +#[test] +fn c126_l739_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 105, 102, 32, 36, 97, 32, 101, 108, 115, 101, 32, 36, 108, 32, 101, 110, 100, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 743 +#[test] +fn c127_l743_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 105, 102, 32, 101, 108, 115, 101, 32, 101, 110, 100, 32, 36, 108, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 747 +#[test] +fn c128_l747_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 105, 102, 32, 101, 108, 115, 101, 32, 36, 108, 32, 101, 110, 100, 32, 36, 108, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 751 +#[test] +fn c129_l751_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 105, 102, 32, 101, 108, 115, 101, 32, 36, 108, 49, 32, 101, 110, 100, 32, 36, 108, 50, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 755 +#[test] +fn c130_l755_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 105, 102, 32, 36, 97, 32, 101, 108, 115, 101, 32, 101, 110, 100, 32, 36, 108, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 759 +#[test] +fn c131_l759_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 105, 102, 32, 36, 97, 32, 101, 108, 115, 101, 32, 36, 97, 32, 101, 110, 100, 32, 36, 108, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 763 +#[test] +fn c132_l763_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 105, 102, 32, 36, 97, 32, 101, 108, 115, 101, 32, 36, 108, 32, 101, 110, 100, 32, 36, 108, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l384_action_invoke(&mut instance); + c2_l385_action_invoke(&mut instance); + c3_l386_action_invoke(&mut instance); + c4_l387_action_invoke(&mut instance); + c5_l389_action_invoke(&mut instance); + c6_l390_action_invoke(&mut instance); + c7_l391_action_invoke(&mut instance); + c8_l392_action_invoke(&mut instance); + c9_l394_action_invoke(&mut instance); + c10_l395_action_invoke(&mut instance); + c11_l396_action_invoke(&mut instance); + c12_l397_action_invoke(&mut instance); + c13_l399_action_invoke(&mut instance); + c14_l400_action_invoke(&mut instance); + c15_l401_action_invoke(&mut instance); + c16_l402_action_invoke(&mut instance); + c17_l403_action_invoke(&mut instance); + c18_l404_action_invoke(&mut instance); + c19_l405_action_invoke(&mut instance); + c20_l406_action_invoke(&mut instance); + c21_l408_action_invoke(&mut instance); + c22_l409_action_invoke(&mut instance); + c23_l410_action_invoke(&mut instance); + c24_l411_action_invoke(&mut instance); + c25_l412_action_invoke(&mut instance); + c26_l413_action_invoke(&mut instance); + c27_l415_action_invoke(&mut instance); + c28_l416_action_invoke(&mut instance); + c29_l417_action_invoke(&mut instance); + c30_l418_action_invoke(&mut instance); + c31_l419_action_invoke(&mut instance); + c32_l420_action_invoke(&mut instance); + c33_l422_action_invoke(&mut instance); + c34_l423_action_invoke(&mut instance); + c35_l425_action_invoke(&mut instance); + c36_l426_action_invoke(&mut instance); + c37_l427_action_invoke(&mut instance); + c38_l428_action_invoke(&mut instance); + c39_l430_action_invoke(&mut instance); + c40_l431_action_invoke(&mut instance); + c41_l432_action_invoke(&mut instance); + c42_l433_action_invoke(&mut instance); + c43_l435_action_invoke(&mut instance); + c44_l436_action_invoke(&mut instance); + c45_l437_action_invoke(&mut instance); + c46_l438_action_invoke(&mut instance); + c47_l439_action_invoke(&mut instance); + c49_l442_action_invoke(&mut instance); + c50_l443_action_invoke(&mut instance); + c51_l444_action_invoke(&mut instance); + c52_l445_action_invoke(&mut instance); + c53_l447_action_invoke(&mut instance); + c54_l448_action_invoke(&mut instance); + c55_l450_action_invoke(&mut instance); + c56_l451_action_invoke(&mut instance); + c57_l453_action_invoke(&mut instance); + c58_l454_action_invoke(&mut instance); + c59_l456_action_invoke(&mut instance); + c60_l457_action_invoke(&mut instance); + c61_l459_action_invoke(&mut instance); + c62_l460_action_invoke(&mut instance); + c63_l462_action_invoke(&mut instance); + c64_l463_action_invoke(&mut instance); + c65_l465_action_invoke(&mut instance); + c66_l466_action_invoke(&mut instance); + c67_l468_action_invoke(&mut instance); + c68_l469_action_invoke(&mut instance); + c69_l471_action_invoke(&mut instance); + c70_l472_action_invoke(&mut instance); + c71_l474_action_invoke(&mut instance); + c72_l475_action_invoke(&mut instance); + c73_l476_action_invoke(&mut instance); + c74_l478_action_invoke(&mut instance); + c75_l479_action_invoke(&mut instance); + c76_l480_action_invoke(&mut instance); + c77_l481_action_invoke(&mut instance); + c78_l483_action_invoke(&mut instance); + c79_l484_action_invoke(&mut instance); + c80_l486_action_invoke(&mut instance); + c81_l487_action_invoke(&mut instance); + c82_l488_action_invoke(&mut instance); + c83_l489_action_invoke(&mut instance); + c84_l491_action_invoke(&mut instance); + c85_l492_action_invoke(&mut instance); + c86_l493_action_invoke(&mut instance); + c87_l495_action_invoke(&mut instance); + c88_l496_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/int_exprs.rs b/lib/runtime/tests/spectests/int_exprs.rs new file mode 100644 index 000000000..3caa2a846 --- /dev/null +++ b/lib/runtime/tests/spectests/int_exprs.rs @@ -0,0 +1,1707 @@ +// 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/int_exprs.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 6 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func (param i32 i32) (result i32))) + (type (;1;) (func (param i64 i64) (result i32))) + (func (;0;) (type 0) (param i32 i32) (result i32) + get_local 0 + i32.const 1 + i32.add + get_local 1 + i32.const 1 + i32.add + i32.lt_s) + (func (;1;) (type 0) (param i32 i32) (result i32) + get_local 0 + i32.const 1 + i32.add + get_local 1 + i32.const 1 + i32.add + i32.lt_u) + (func (;2;) (type 1) (param i64 i64) (result i32) + get_local 0 + i64.const 1 + i64.add + get_local 1 + i64.const 1 + i64.add + i64.lt_s) + (func (;3;) (type 1) (param i64 i64) (result i32) + get_local 0 + i64.const 1 + i64.add + get_local 1 + i64.const 1 + i64.add + i64.lt_u) + (export \"i32.no_fold_cmp_s_offset\" (func 0)) + (export \"i32.no_fold_cmp_u_offset\" (func 1)) + (export \"i64.no_fold_cmp_s_offset\" (func 2)) + (export \"i64.no_fold_cmp_u_offset\" (func 3))) + "; + 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 18 +fn c1_l18_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l18_action_invoke"); + let result = instance.call("i32.no_fold_cmp_s_offset", &[Value::I32(2147483647 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 19 +fn c2_l19_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l19_action_invoke"); + let result = instance.call("i32.no_fold_cmp_u_offset", &[Value::I32(-1 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 20 +fn c3_l20_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l20_action_invoke"); + let result = instance.call("i64.no_fold_cmp_s_offset", &[Value::I64(9223372036854775807 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 21 +fn c4_l21_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l21_action_invoke"); + let result = instance.call("i64.no_fold_cmp_u_offset", &[Value::I64(-1 as i64), Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 25 + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l18_action_invoke(&mut instance); + c2_l19_action_invoke(&mut instance); + c3_l20_action_invoke(&mut instance); + c4_l21_action_invoke(&mut instance); +} +fn create_module_2() -> Box { + let module_str = "(module + (type (;0;) (func (param i64) (result i64))) + (func (;0;) (type 0) (param i64) (result i64) + get_local 0 + i32.wrap/i64 + i64.extend_s/i32) + (export \"i64.no_fold_wrap_extend_s\" (func 0))) + "; + 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_2(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 30 +fn c6_l30_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l30_action_invoke"); + let result = instance.call("i64.no_fold_wrap_extend_s", &[Value::I64(4538991236898928 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1079009392 as i64)))); + result.map(|_| ()) +} + +// Line 31 +fn c7_l31_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l31_action_invoke"); + let result = instance.call("i64.no_fold_wrap_extend_s", &[Value::I64(45230338458316960 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-790564704 as i64)))); + result.map(|_| ()) +} + +// Line 35 + +#[test] +fn test_module_2() { + let mut instance = create_module_2(); + // We group the calls together + start_module_2(&mut instance); + c6_l30_action_invoke(&mut instance); + c7_l31_action_invoke(&mut instance); +} +fn create_module_3() -> Box { + let module_str = "(module + (type (;0;) (func (param i64) (result i64))) + (func (;0;) (type 0) (param i64) (result i64) + get_local 0 + i32.wrap/i64 + i64.extend_u/i32) + (export \"i64.no_fold_wrap_extend_u\" (func 0))) + "; + 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_3(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 40 +fn c9_l40_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l40_action_invoke"); + let result = instance.call("i64.no_fold_wrap_extend_u", &[Value::I64(4538991236898928 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1079009392 as i64)))); + result.map(|_| ()) +} + +// Line 44 + +#[test] +fn test_module_3() { + let mut instance = create_module_3(); + // We group the calls together + start_module_3(&mut instance); + c9_l40_action_invoke(&mut instance); +} +fn create_module_4() -> Box { + let module_str = "(module + (type (;0;) (func (param i32) (result i32))) + (type (;1;) (func (param i64) (result i64))) + (func (;0;) (type 0) (param i32) (result i32) + get_local 0 + i32.const 1 + i32.shl + i32.const 1 + i32.shr_s) + (func (;1;) (type 0) (param i32) (result i32) + get_local 0 + i32.const 1 + i32.shl + i32.const 1 + i32.shr_u) + (func (;2;) (type 1) (param i64) (result i64) + get_local 0 + i64.const 1 + i64.shl + i64.const 1 + i64.shr_s) + (func (;3;) (type 1) (param i64) (result i64) + get_local 0 + i64.const 1 + i64.shl + i64.const 1 + i64.shr_u) + (export \"i32.no_fold_shl_shr_s\" (func 0)) + (export \"i32.no_fold_shl_shr_u\" (func 1)) + (export \"i64.no_fold_shl_shr_s\" (func 2)) + (export \"i64.no_fold_shl_shr_u\" (func 3))) + "; + 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_4(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 56 +fn c11_l56_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c11_l56_action_invoke"); + let result = instance.call("i32.no_fold_shl_shr_s", &[Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 57 +fn c12_l57_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c12_l57_action_invoke"); + let result = instance.call("i32.no_fold_shl_shr_u", &[Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 58 +fn c13_l58_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c13_l58_action_invoke"); + let result = instance.call("i64.no_fold_shl_shr_s", &[Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 59 +fn c14_l59_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c14_l59_action_invoke"); + let result = instance.call("i64.no_fold_shl_shr_u", &[Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 63 + +#[test] +fn test_module_4() { + let mut instance = create_module_4(); + // We group the calls together + start_module_4(&mut instance); + c11_l56_action_invoke(&mut instance); + c12_l57_action_invoke(&mut instance); + c13_l58_action_invoke(&mut instance); + c14_l59_action_invoke(&mut instance); +} +fn create_module_5() -> Box { + let module_str = "(module + (type (;0;) (func (param i32) (result i32))) + (type (;1;) (func (param i64) (result i64))) + (func (;0;) (type 0) (param i32) (result i32) + get_local 0 + i32.const 1 + i32.shr_s + i32.const 1 + i32.shl) + (func (;1;) (type 0) (param i32) (result i32) + get_local 0 + i32.const 1 + i32.shr_u + i32.const 1 + i32.shl) + (func (;2;) (type 1) (param i64) (result i64) + get_local 0 + i64.const 1 + i64.shr_s + i64.const 1 + i64.shl) + (func (;3;) (type 1) (param i64) (result i64) + get_local 0 + i64.const 1 + i64.shr_u + i64.const 1 + i64.shl) + (export \"i32.no_fold_shr_s_shl\" (func 0)) + (export \"i32.no_fold_shr_u_shl\" (func 1)) + (export \"i64.no_fold_shr_s_shl\" (func 2)) + (export \"i64.no_fold_shr_u_shl\" (func 3))) + "; + 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_5(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 75 +fn c16_l75_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c16_l75_action_invoke"); + let result = instance.call("i32.no_fold_shr_s_shl", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 76 +fn c17_l76_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c17_l76_action_invoke"); + let result = instance.call("i32.no_fold_shr_u_shl", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 77 +fn c18_l77_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c18_l77_action_invoke"); + let result = instance.call("i64.no_fold_shr_s_shl", &[Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 78 +fn c19_l78_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c19_l78_action_invoke"); + let result = instance.call("i64.no_fold_shr_u_shl", &[Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 82 + +#[test] +fn test_module_5() { + let mut instance = create_module_5(); + // We group the calls together + start_module_5(&mut instance); + c16_l75_action_invoke(&mut instance); + c17_l76_action_invoke(&mut instance); + c18_l77_action_invoke(&mut instance); + c19_l78_action_invoke(&mut instance); +} +fn create_module_6() -> Box { + let module_str = "(module + (type (;0;) (func (param i32) (result i32))) + (type (;1;) (func (param i64) (result i64))) + (func (;0;) (type 0) (param i32) (result i32) + get_local 0 + i32.const 6 + i32.div_s + i32.const 6 + i32.mul) + (func (;1;) (type 0) (param i32) (result i32) + get_local 0 + i32.const 6 + i32.div_u + i32.const 6 + i32.mul) + (func (;2;) (type 1) (param i64) (result i64) + get_local 0 + i64.const 6 + i64.div_s + i64.const 6 + i64.mul) + (func (;3;) (type 1) (param i64) (result i64) + get_local 0 + i64.const 6 + i64.div_u + i64.const 6 + i64.mul) + (export \"i32.no_fold_div_s_mul\" (func 0)) + (export \"i32.no_fold_div_u_mul\" (func 1)) + (export \"i64.no_fold_div_s_mul\" (func 2)) + (export \"i64.no_fold_div_u_mul\" (func 3))) + "; + 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_6(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 94 +fn c21_l94_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c21_l94_action_invoke"); + let result = instance.call("i32.no_fold_div_s_mul", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 95 +fn c22_l95_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c22_l95_action_invoke"); + let result = instance.call("i32.no_fold_div_u_mul", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 96 +fn c23_l96_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c23_l96_action_invoke"); + let result = instance.call("i64.no_fold_div_s_mul", &[Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 97 +fn c24_l97_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c24_l97_action_invoke"); + let result = instance.call("i64.no_fold_div_u_mul", &[Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 101 + +#[test] +fn test_module_6() { + let mut instance = create_module_6(); + // We group the calls together + start_module_6(&mut instance); + c21_l94_action_invoke(&mut instance); + c22_l95_action_invoke(&mut instance); + c23_l96_action_invoke(&mut instance); + c24_l97_action_invoke(&mut instance); +} +fn create_module_7() -> Box { + let module_str = "(module + (type (;0;) (func (param i32) (result i32))) + (type (;1;) (func (param i64) (result i64))) + (func (;0;) (type 0) (param i32) (result i32) + get_local 0 + get_local 0 + i32.div_s) + (func (;1;) (type 0) (param i32) (result i32) + get_local 0 + get_local 0 + i32.div_u) + (func (;2;) (type 1) (param i64) (result i64) + get_local 0 + get_local 0 + i64.div_s) + (func (;3;) (type 1) (param i64) (result i64) + get_local 0 + get_local 0 + i64.div_u) + (export \"i32.no_fold_div_s_self\" (func 0)) + (export \"i32.no_fold_div_u_self\" (func 1)) + (export \"i64.no_fold_div_s_self\" (func 2)) + (export \"i64.no_fold_div_u_self\" (func 3))) + "; + 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_7(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 113 +fn c26_l113_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c26_l113_action_invoke"); + let result = instance.call("i32.no_fold_div_s_self", &[Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c26_l113_assert_trap() { + let mut instance = create_module_7(); + let result = c26_l113_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 114 +fn c27_l114_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c27_l114_action_invoke"); + let result = instance.call("i32.no_fold_div_u_self", &[Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c27_l114_assert_trap() { + let mut instance = create_module_7(); + let result = c27_l114_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 115 +fn c28_l115_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c28_l115_action_invoke"); + let result = instance.call("i64.no_fold_div_s_self", &[Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c28_l115_assert_trap() { + let mut instance = create_module_7(); + let result = c28_l115_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 116 +fn c29_l116_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c29_l116_action_invoke"); + let result = instance.call("i64.no_fold_div_u_self", &[Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c29_l116_assert_trap() { + let mut instance = create_module_7(); + let result = c29_l116_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 120 + +#[test] +fn test_module_7() { + let mut instance = create_module_7(); + // We group the calls together + start_module_7(&mut instance); +} +fn create_module_8() -> Box { + let module_str = "(module + (type (;0;) (func (param i32) (result i32))) + (type (;1;) (func (param i64) (result i64))) + (func (;0;) (type 0) (param i32) (result i32) + get_local 0 + get_local 0 + i32.rem_s) + (func (;1;) (type 0) (param i32) (result i32) + get_local 0 + get_local 0 + i32.rem_u) + (func (;2;) (type 1) (param i64) (result i64) + get_local 0 + get_local 0 + i64.rem_s) + (func (;3;) (type 1) (param i64) (result i64) + get_local 0 + get_local 0 + i64.rem_u) + (export \"i32.no_fold_rem_s_self\" (func 0)) + (export \"i32.no_fold_rem_u_self\" (func 1)) + (export \"i64.no_fold_rem_s_self\" (func 2)) + (export \"i64.no_fold_rem_u_self\" (func 3))) + "; + 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_8(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 132 +fn c31_l132_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c31_l132_action_invoke"); + let result = instance.call("i32.no_fold_rem_s_self", &[Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c31_l132_assert_trap() { + let mut instance = create_module_8(); + let result = c31_l132_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 133 +fn c32_l133_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c32_l133_action_invoke"); + let result = instance.call("i32.no_fold_rem_u_self", &[Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c32_l133_assert_trap() { + let mut instance = create_module_8(); + let result = c32_l133_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 134 +fn c33_l134_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c33_l134_action_invoke"); + let result = instance.call("i64.no_fold_rem_s_self", &[Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c33_l134_assert_trap() { + let mut instance = create_module_8(); + let result = c33_l134_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 135 +fn c34_l135_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c34_l135_action_invoke"); + let result = instance.call("i64.no_fold_rem_u_self", &[Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c34_l135_assert_trap() { + let mut instance = create_module_8(); + let result = c34_l135_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 139 + +#[test] +fn test_module_8() { + let mut instance = create_module_8(); + // We group the calls together + start_module_8(&mut instance); +} +fn create_module_9() -> Box { + let module_str = "(module + (type (;0;) (func (param i32) (result i32))) + (type (;1;) (func (param i64) (result i64))) + (func (;0;) (type 0) (param i32) (result i32) + get_local 0 + i32.const 6 + i32.mul + i32.const 6 + i32.div_s) + (func (;1;) (type 0) (param i32) (result i32) + get_local 0 + i32.const 6 + i32.mul + i32.const 6 + i32.div_u) + (func (;2;) (type 1) (param i64) (result i64) + get_local 0 + i64.const 6 + i64.mul + i64.const 6 + i64.div_s) + (func (;3;) (type 1) (param i64) (result i64) + get_local 0 + i64.const 6 + i64.mul + i64.const 6 + i64.div_u) + (export \"i32.no_fold_mul_div_s\" (func 0)) + (export \"i32.no_fold_mul_div_u\" (func 1)) + (export \"i64.no_fold_mul_div_s\" (func 2)) + (export \"i64.no_fold_mul_div_u\" (func 3))) + "; + 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_9(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 151 +fn c36_l151_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c36_l151_action_invoke"); + let result = instance.call("i32.no_fold_mul_div_s", &[Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 152 +fn c37_l152_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c37_l152_action_invoke"); + let result = instance.call("i32.no_fold_mul_div_u", &[Value::I32(-2147483648 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 153 +fn c38_l153_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c38_l153_action_invoke"); + let result = instance.call("i64.no_fold_mul_div_s", &[Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 154 +fn c39_l154_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c39_l154_action_invoke"); + let result = instance.call("i64.no_fold_mul_div_u", &[Value::I64(-9223372036854775808 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 158 + +#[test] +fn test_module_9() { + let mut instance = create_module_9(); + // We group the calls together + start_module_9(&mut instance); + c36_l151_action_invoke(&mut instance); + c37_l152_action_invoke(&mut instance); + c38_l153_action_invoke(&mut instance); + c39_l154_action_invoke(&mut instance); +} +fn create_module_10() -> Box { + let module_str = "(module + (type (;0;) (func (param i32) (result i32))) + (type (;1;) (func (param i64) (result i64))) + (func (;0;) (type 0) (param i32) (result i32) + get_local 0 + i32.const 2 + i32.div_s) + (func (;1;) (type 1) (param i64) (result i64) + get_local 0 + i64.const 2 + i64.div_s) + (export \"i32.no_fold_div_s_2\" (func 0)) + (export \"i64.no_fold_div_s_2\" (func 1))) + "; + 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_10(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 166 +fn c41_l166_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c41_l166_action_invoke"); + let result = instance.call("i32.no_fold_div_s_2", &[Value::I32(-11 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-5 as i32)))); + result.map(|_| ()) +} + +// Line 167 +fn c42_l167_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c42_l167_action_invoke"); + let result = instance.call("i64.no_fold_div_s_2", &[Value::I64(-11 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-5 as i64)))); + result.map(|_| ()) +} + +// Line 171 + +#[test] +fn test_module_10() { + let mut instance = create_module_10(); + // We group the calls together + start_module_10(&mut instance); + c41_l166_action_invoke(&mut instance); + c42_l167_action_invoke(&mut instance); +} +fn create_module_11() -> Box { + let module_str = "(module + (type (;0;) (func (param i32) (result i32))) + (type (;1;) (func (param i64) (result i64))) + (func (;0;) (type 0) (param i32) (result i32) + get_local 0 + i32.const 2 + i32.rem_s) + (func (;1;) (type 1) (param i64) (result i64) + get_local 0 + i64.const 2 + i64.rem_s) + (export \"i32.no_fold_rem_s_2\" (func 0)) + (export \"i64.no_fold_rem_s_2\" (func 1))) + "; + 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_11(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 179 +fn c44_l179_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c44_l179_action_invoke"); + let result = instance.call("i32.no_fold_rem_s_2", &[Value::I32(-11 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 180 +fn c45_l180_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c45_l180_action_invoke"); + let result = instance.call("i64.no_fold_rem_s_2", &[Value::I64(-11 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); + result.map(|_| ()) +} + +// Line 184 + +#[test] +fn test_module_11() { + let mut instance = create_module_11(); + // We group the calls together + start_module_11(&mut instance); + c44_l179_action_invoke(&mut instance); + c45_l180_action_invoke(&mut instance); +} +fn create_module_12() -> Box { + let module_str = "(module + (type (;0;) (func (param i32) (result i32))) + (type (;1;) (func (param i64) (result i64))) + (func (;0;) (type 0) (param i32) (result i32) + get_local 0 + i32.const 0 + i32.div_s) + (func (;1;) (type 0) (param i32) (result i32) + get_local 0 + i32.const 0 + i32.div_u) + (func (;2;) (type 1) (param i64) (result i64) + get_local 0 + i64.const 0 + i64.div_s) + (func (;3;) (type 1) (param i64) (result i64) + get_local 0 + i64.const 0 + i64.div_u) + (export \"i32.div_s_0\" (func 0)) + (export \"i32.div_u_0\" (func 1)) + (export \"i64.div_s_0\" (func 2)) + (export \"i64.div_u_0\" (func 3))) + "; + 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_12(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 196 +fn c47_l196_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c47_l196_action_invoke"); + let result = instance.call("i32.div_s_0", &[Value::I32(71 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c47_l196_assert_trap() { + let mut instance = create_module_12(); + let result = c47_l196_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 197 +fn c48_l197_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c48_l197_action_invoke"); + let result = instance.call("i32.div_u_0", &[Value::I32(71 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c48_l197_assert_trap() { + let mut instance = create_module_12(); + let result = c48_l197_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 198 +fn c49_l198_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c49_l198_action_invoke"); + let result = instance.call("i64.div_s_0", &[Value::I64(71 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c49_l198_assert_trap() { + let mut instance = create_module_12(); + let result = c49_l198_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 199 +fn c50_l199_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c50_l199_action_invoke"); + let result = instance.call("i64.div_u_0", &[Value::I64(71 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c50_l199_assert_trap() { + let mut instance = create_module_12(); + let result = c50_l199_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 203 + +#[test] +fn test_module_12() { + let mut instance = create_module_12(); + // We group the calls together + start_module_12(&mut instance); +} +fn create_module_13() -> Box { + let module_str = "(module + (type (;0;) (func (param i32) (result i32))) + (type (;1;) (func (param i64) (result i64))) + (func (;0;) (type 0) (param i32) (result i32) + get_local 0 + i32.const 3 + i32.div_s) + (func (;1;) (type 0) (param i32) (result i32) + get_local 0 + i32.const 3 + i32.div_u) + (func (;2;) (type 1) (param i64) (result i64) + get_local 0 + i64.const 3 + i64.div_s) + (func (;3;) (type 1) (param i64) (result i64) + get_local 0 + i64.const 3 + i64.div_u) + (export \"i32.div_s_3\" (func 0)) + (export \"i32.div_u_3\" (func 1)) + (export \"i64.div_s_3\" (func 2)) + (export \"i64.div_u_3\" (func 3))) + "; + 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_13(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 215 +fn c52_l215_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c52_l215_action_invoke"); + let result = instance.call("i32.div_s_3", &[Value::I32(71 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(23 as i32)))); + result.map(|_| ()) +} + +// Line 216 +fn c53_l216_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c53_l216_action_invoke"); + let result = instance.call("i32.div_s_3", &[Value::I32(1610612736 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(536870912 as i32)))); + result.map(|_| ()) +} + +// Line 217 +fn c54_l217_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c54_l217_action_invoke"); + let result = instance.call("i32.div_u_3", &[Value::I32(71 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(23 as i32)))); + result.map(|_| ()) +} + +// Line 218 +fn c55_l218_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c55_l218_action_invoke"); + let result = instance.call("i32.div_u_3", &[Value::I32(-1073741824 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1073741824 as i32)))); + result.map(|_| ()) +} + +// Line 219 +fn c56_l219_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c56_l219_action_invoke"); + let result = instance.call("i64.div_s_3", &[Value::I64(71 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(23 as i64)))); + result.map(|_| ()) +} + +// Line 220 +fn c57_l220_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c57_l220_action_invoke"); + let result = instance.call("i64.div_s_3", &[Value::I64(3458764513820540928 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1152921504606846976 as i64)))); + result.map(|_| ()) +} + +// Line 221 +fn c58_l221_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c58_l221_action_invoke"); + let result = instance.call("i64.div_u_3", &[Value::I64(71 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(23 as i64)))); + result.map(|_| ()) +} + +// Line 222 +fn c59_l222_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c59_l222_action_invoke"); + let result = instance.call("i64.div_u_3", &[Value::I64(-4611686018427387904 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(4611686018427387904 as i64)))); + result.map(|_| ()) +} + +// Line 226 + +#[test] +fn test_module_13() { + let mut instance = create_module_13(); + // We group the calls together + start_module_13(&mut instance); + c52_l215_action_invoke(&mut instance); + c53_l216_action_invoke(&mut instance); + c54_l217_action_invoke(&mut instance); + c55_l218_action_invoke(&mut instance); + c56_l219_action_invoke(&mut instance); + c57_l220_action_invoke(&mut instance); + c58_l221_action_invoke(&mut instance); + c59_l222_action_invoke(&mut instance); +} +fn create_module_14() -> Box { + let module_str = "(module + (type (;0;) (func (param i32) (result i32))) + (type (;1;) (func (param i64) (result i64))) + (func (;0;) (type 0) (param i32) (result i32) + get_local 0 + i32.const 5 + i32.div_s) + (func (;1;) (type 0) (param i32) (result i32) + get_local 0 + i32.const 5 + i32.div_u) + (func (;2;) (type 1) (param i64) (result i64) + get_local 0 + i64.const 5 + i64.div_s) + (func (;3;) (type 1) (param i64) (result i64) + get_local 0 + i64.const 5 + i64.div_u) + (export \"i32.div_s_5\" (func 0)) + (export \"i32.div_u_5\" (func 1)) + (export \"i64.div_s_5\" (func 2)) + (export \"i64.div_u_5\" (func 3))) + "; + 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_14(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 238 +fn c61_l238_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c61_l238_action_invoke"); + let result = instance.call("i32.div_s_5", &[Value::I32(71 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(14 as i32)))); + result.map(|_| ()) +} + +// Line 239 +fn c62_l239_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c62_l239_action_invoke"); + let result = instance.call("i32.div_s_5", &[Value::I32(1342177280 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(268435456 as i32)))); + result.map(|_| ()) +} + +// Line 240 +fn c63_l240_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c63_l240_action_invoke"); + let result = instance.call("i32.div_u_5", &[Value::I32(71 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(14 as i32)))); + result.map(|_| ()) +} + +// Line 241 +fn c64_l241_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c64_l241_action_invoke"); + let result = instance.call("i32.div_u_5", &[Value::I32(-1610612736 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(536870912 as i32)))); + result.map(|_| ()) +} + +// Line 242 +fn c65_l242_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c65_l242_action_invoke"); + let result = instance.call("i64.div_s_5", &[Value::I64(71 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(14 as i64)))); + result.map(|_| ()) +} + +// Line 243 +fn c66_l243_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c66_l243_action_invoke"); + let result = instance.call("i64.div_s_5", &[Value::I64(5764607523034234880 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1152921504606846976 as i64)))); + result.map(|_| ()) +} + +// Line 244 +fn c67_l244_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c67_l244_action_invoke"); + let result = instance.call("i64.div_u_5", &[Value::I64(71 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(14 as i64)))); + result.map(|_| ()) +} + +// Line 245 +fn c68_l245_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c68_l245_action_invoke"); + let result = instance.call("i64.div_u_5", &[Value::I64(-6917529027641081856 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(2305843009213693952 as i64)))); + result.map(|_| ()) +} + +// Line 249 + +#[test] +fn test_module_14() { + let mut instance = create_module_14(); + // We group the calls together + start_module_14(&mut instance); + c61_l238_action_invoke(&mut instance); + c62_l239_action_invoke(&mut instance); + c63_l240_action_invoke(&mut instance); + c64_l241_action_invoke(&mut instance); + c65_l242_action_invoke(&mut instance); + c66_l243_action_invoke(&mut instance); + c67_l244_action_invoke(&mut instance); + c68_l245_action_invoke(&mut instance); +} +fn create_module_15() -> Box { + let module_str = "(module + (type (;0;) (func (param i32) (result i32))) + (type (;1;) (func (param i64) (result i64))) + (func (;0;) (type 0) (param i32) (result i32) + get_local 0 + i32.const 7 + i32.div_s) + (func (;1;) (type 0) (param i32) (result i32) + get_local 0 + i32.const 7 + i32.div_u) + (func (;2;) (type 1) (param i64) (result i64) + get_local 0 + i64.const 7 + i64.div_s) + (func (;3;) (type 1) (param i64) (result i64) + get_local 0 + i64.const 7 + i64.div_u) + (export \"i32.div_s_7\" (func 0)) + (export \"i32.div_u_7\" (func 1)) + (export \"i64.div_s_7\" (func 2)) + (export \"i64.div_u_7\" (func 3))) + "; + 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_15(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 261 +fn c70_l261_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c70_l261_action_invoke"); + let result = instance.call("i32.div_s_7", &[Value::I32(71 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); + result.map(|_| ()) +} + +// Line 262 +fn c71_l262_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c71_l262_action_invoke"); + let result = instance.call("i32.div_s_7", &[Value::I32(1879048192 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(268435456 as i32)))); + result.map(|_| ()) +} + +// Line 263 +fn c72_l263_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c72_l263_action_invoke"); + let result = instance.call("i32.div_u_7", &[Value::I32(71 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); + result.map(|_| ()) +} + +// Line 264 +fn c73_l264_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c73_l264_action_invoke"); + let result = instance.call("i32.div_u_7", &[Value::I32(-536870912 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(536870912 as i32)))); + result.map(|_| ()) +} + +// Line 265 +fn c74_l265_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c74_l265_action_invoke"); + let result = instance.call("i64.div_s_7", &[Value::I64(71 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); + result.map(|_| ()) +} + +// Line 266 +fn c75_l266_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c75_l266_action_invoke"); + let result = instance.call("i64.div_s_7", &[Value::I64(8070450532247928832 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1152921504606846976 as i64)))); + result.map(|_| ()) +} + +// Line 267 +fn c76_l267_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c76_l267_action_invoke"); + let result = instance.call("i64.div_u_7", &[Value::I64(71 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); + result.map(|_| ()) +} + +// Line 268 +fn c77_l268_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c77_l268_action_invoke"); + let result = instance.call("i64.div_u_7", &[Value::I64(-2305843009213693952 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(2305843009213693952 as i64)))); + result.map(|_| ()) +} + +// Line 272 + +#[test] +fn test_module_15() { + let mut instance = create_module_15(); + // We group the calls together + start_module_15(&mut instance); + c70_l261_action_invoke(&mut instance); + c71_l262_action_invoke(&mut instance); + c72_l263_action_invoke(&mut instance); + c73_l264_action_invoke(&mut instance); + c74_l265_action_invoke(&mut instance); + c75_l266_action_invoke(&mut instance); + c76_l267_action_invoke(&mut instance); + c77_l268_action_invoke(&mut instance); +} +fn create_module_16() -> Box { + let module_str = "(module + (type (;0;) (func (param i32) (result i32))) + (type (;1;) (func (param i64) (result i64))) + (func (;0;) (type 0) (param i32) (result i32) + get_local 0 + i32.const 3 + i32.rem_s) + (func (;1;) (type 0) (param i32) (result i32) + get_local 0 + i32.const 3 + i32.rem_u) + (func (;2;) (type 1) (param i64) (result i64) + get_local 0 + i64.const 3 + i64.rem_s) + (func (;3;) (type 1) (param i64) (result i64) + get_local 0 + i64.const 3 + i64.rem_u) + (export \"i32.rem_s_3\" (func 0)) + (export \"i32.rem_u_3\" (func 1)) + (export \"i64.rem_s_3\" (func 2)) + (export \"i64.rem_u_3\" (func 3))) + "; + 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_16(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 284 +fn c79_l284_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c79_l284_action_invoke"); + let result = instance.call("i32.rem_s_3", &[Value::I32(71 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 285 +fn c80_l285_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c80_l285_action_invoke"); + let result = instance.call("i32.rem_s_3", &[Value::I32(1610612736 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 286 +fn c81_l286_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c81_l286_action_invoke"); + let result = instance.call("i32.rem_u_3", &[Value::I32(71 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 287 +fn c82_l287_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c82_l287_action_invoke"); + let result = instance.call("i32.rem_u_3", &[Value::I32(-1073741824 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 288 +fn c83_l288_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c83_l288_action_invoke"); + let result = instance.call("i64.rem_s_3", &[Value::I64(71 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(2 as i64)))); + result.map(|_| ()) +} + +// Line 289 +fn c84_l289_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c84_l289_action_invoke"); + let result = instance.call("i64.rem_s_3", &[Value::I64(3458764513820540928 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 290 +fn c85_l290_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c85_l290_action_invoke"); + let result = instance.call("i64.rem_u_3", &[Value::I64(71 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(2 as i64)))); + result.map(|_| ()) +} + +// Line 291 +fn c86_l291_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c86_l291_action_invoke"); + let result = instance.call("i64.rem_u_3", &[Value::I64(-4611686018427387904 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 295 + +#[test] +fn test_module_16() { + let mut instance = create_module_16(); + // We group the calls together + start_module_16(&mut instance); + c79_l284_action_invoke(&mut instance); + c80_l285_action_invoke(&mut instance); + c81_l286_action_invoke(&mut instance); + c82_l287_action_invoke(&mut instance); + c83_l288_action_invoke(&mut instance); + c84_l289_action_invoke(&mut instance); + c85_l290_action_invoke(&mut instance); + c86_l291_action_invoke(&mut instance); +} +fn create_module_17() -> Box { + let module_str = "(module + (type (;0;) (func (param i32) (result i32))) + (type (;1;) (func (param i64) (result i64))) + (func (;0;) (type 0) (param i32) (result i32) + get_local 0 + i32.const 5 + i32.rem_s) + (func (;1;) (type 0) (param i32) (result i32) + get_local 0 + i32.const 5 + i32.rem_u) + (func (;2;) (type 1) (param i64) (result i64) + get_local 0 + i64.const 5 + i64.rem_s) + (func (;3;) (type 1) (param i64) (result i64) + get_local 0 + i64.const 5 + i64.rem_u) + (export \"i32.rem_s_5\" (func 0)) + (export \"i32.rem_u_5\" (func 1)) + (export \"i64.rem_s_5\" (func 2)) + (export \"i64.rem_u_5\" (func 3))) + "; + 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_17(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 307 +fn c88_l307_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c88_l307_action_invoke"); + let result = instance.call("i32.rem_s_5", &[Value::I32(71 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 308 +fn c89_l308_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c89_l308_action_invoke"); + let result = instance.call("i32.rem_s_5", &[Value::I32(1342177280 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 309 +fn c90_l309_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c90_l309_action_invoke"); + let result = instance.call("i32.rem_u_5", &[Value::I32(71 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 310 +fn c91_l310_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c91_l310_action_invoke"); + let result = instance.call("i32.rem_u_5", &[Value::I32(-1610612736 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 311 +fn c92_l311_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c92_l311_action_invoke"); + let result = instance.call("i64.rem_s_5", &[Value::I64(71 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 312 +fn c93_l312_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c93_l312_action_invoke"); + let result = instance.call("i64.rem_s_5", &[Value::I64(5764607523034234880 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 313 +fn c94_l313_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c94_l313_action_invoke"); + let result = instance.call("i64.rem_u_5", &[Value::I64(71 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 314 +fn c95_l314_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c95_l314_action_invoke"); + let result = instance.call("i64.rem_u_5", &[Value::I64(-6917529027641081856 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 318 + +#[test] +fn test_module_17() { + let mut instance = create_module_17(); + // We group the calls together + start_module_17(&mut instance); + c88_l307_action_invoke(&mut instance); + c89_l308_action_invoke(&mut instance); + c90_l309_action_invoke(&mut instance); + c91_l310_action_invoke(&mut instance); + c92_l311_action_invoke(&mut instance); + c93_l312_action_invoke(&mut instance); + c94_l313_action_invoke(&mut instance); + c95_l314_action_invoke(&mut instance); +} +fn create_module_18() -> Box { + let module_str = "(module + (type (;0;) (func (param i32) (result i32))) + (type (;1;) (func (param i64) (result i64))) + (func (;0;) (type 0) (param i32) (result i32) + get_local 0 + i32.const 7 + i32.rem_s) + (func (;1;) (type 0) (param i32) (result i32) + get_local 0 + i32.const 7 + i32.rem_u) + (func (;2;) (type 1) (param i64) (result i64) + get_local 0 + i64.const 7 + i64.rem_s) + (func (;3;) (type 1) (param i64) (result i64) + get_local 0 + i64.const 7 + i64.rem_u) + (export \"i32.rem_s_7\" (func 0)) + (export \"i32.rem_u_7\" (func 1)) + (export \"i64.rem_s_7\" (func 2)) + (export \"i64.rem_u_7\" (func 3))) + "; + 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_18(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 330 +fn c97_l330_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c97_l330_action_invoke"); + let result = instance.call("i32.rem_s_7", &[Value::I32(71 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 331 +fn c98_l331_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c98_l331_action_invoke"); + let result = instance.call("i32.rem_s_7", &[Value::I32(1879048192 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 332 +fn c99_l332_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c99_l332_action_invoke"); + let result = instance.call("i32.rem_u_7", &[Value::I32(71 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 333 +fn c100_l333_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c100_l333_action_invoke"); + let result = instance.call("i32.rem_u_7", &[Value::I32(-536870912 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 334 +fn c101_l334_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c101_l334_action_invoke"); + let result = instance.call("i64.rem_s_7", &[Value::I64(71 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 335 +fn c102_l335_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c102_l335_action_invoke"); + let result = instance.call("i64.rem_s_7", &[Value::I64(8070450532247928832 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 336 +fn c103_l336_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c103_l336_action_invoke"); + let result = instance.call("i64.rem_u_7", &[Value::I64(71 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 337 +fn c104_l337_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c104_l337_action_invoke"); + let result = instance.call("i64.rem_u_7", &[Value::I64(-2305843009213693952 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 341 + +#[test] +fn test_module_18() { + let mut instance = create_module_18(); + // We group the calls together + start_module_18(&mut instance); + c97_l330_action_invoke(&mut instance); + c98_l331_action_invoke(&mut instance); + c99_l332_action_invoke(&mut instance); + c100_l333_action_invoke(&mut instance); + c101_l334_action_invoke(&mut instance); + c102_l335_action_invoke(&mut instance); + c103_l336_action_invoke(&mut instance); + c104_l337_action_invoke(&mut instance); +} +fn create_module_19() -> Box { + let module_str = "(module + (type (;0;) (func (param i32) (result i32))) + (type (;1;) (func (param i64) (result i64))) + (func (;0;) (type 0) (param i32) (result i32) + get_local 0 + i32.const -1 + i32.div_s) + (func (;1;) (type 1) (param i64) (result i64) + get_local 0 + i64.const -1 + i64.div_s) + (export \"i32.no_fold_div_neg1\" (func 0)) + (export \"i64.no_fold_div_neg1\" (func 1))) + "; + 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_19(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 349 +fn c106_l349_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c106_l349_action_invoke"); + let result = instance.call("i32.no_fold_div_neg1", &[Value::I32(-2147483648 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c106_l349_assert_trap() { + let mut instance = create_module_19(); + let result = c106_l349_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 350 +fn c107_l350_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c107_l350_action_invoke"); + let result = instance.call("i64.no_fold_div_neg1", &[Value::I64(-9223372036854775808 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c107_l350_assert_trap() { + let mut instance = create_module_19(); + let result = c107_l350_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +#[test] +fn test_module_19() { + let mut instance = create_module_19(); + // We group the calls together + start_module_19(&mut instance); +} diff --git a/lib/runtime/tests/spectests/int_literals.rs b/lib/runtime/tests/spectests/int_literals.rs new file mode 100644 index 000000000..52bfa9860 --- /dev/null +++ b/lib/runtime/tests/spectests/int_literals.rs @@ -0,0 +1,588 @@ +// 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/int_literals.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 1 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func (result i32))) + (type (;1;) (func (result i64))) + (func (;0;) (type 0) (result i32) + i32.const 195940365 + return) + (func (;1;) (type 0) (result i32) + i32.const -1 + return) + (func (;2;) (type 0) (result i32) + i32.const 2147483647 + return) + (func (;3;) (type 0) (result i32) + i32.const -2147483647 + return) + (func (;4;) (type 0) (result i32) + i32.const -2147483648 + return) + (func (;5;) (type 0) (result i32) + i32.const -2147483648 + return) + (func (;6;) (type 0) (result i32) + i32.const -2147483648 + i32.const 1 + i32.add + return) + (func (;7;) (type 0) (result i32) + i32.const 0 + return) + (func (;8;) (type 0) (result i32) + i32.const 10 + return) + (func (;9;) (type 0) (result i32) + i32.const -1 + return) + (func (;10;) (type 0) (result i32) + i32.const 42 + return) + (func (;11;) (type 1) (result i64) + i64.const 913028331277281902 + return) + (func (;12;) (type 1) (result i64) + i64.const -1 + return) + (func (;13;) (type 1) (result i64) + i64.const 9223372036854775807 + return) + (func (;14;) (type 1) (result i64) + i64.const -9223372036854775807 + return) + (func (;15;) (type 1) (result i64) + i64.const -9223372036854775808 + return) + (func (;16;) (type 1) (result i64) + i64.const -9223372036854775808 + return) + (func (;17;) (type 1) (result i64) + i64.const -9223372036854775808 + i64.const 1 + i64.add + return) + (func (;18;) (type 1) (result i64) + i64.const 0 + return) + (func (;19;) (type 1) (result i64) + i64.const 10 + return) + (func (;20;) (type 1) (result i64) + i64.const -1 + return) + (func (;21;) (type 1) (result i64) + i64.const 42 + return) + (func (;22;) (type 0) (result i32) + i32.const 1000000) + (func (;23;) (type 0) (result i32) + i32.const 1000) + (func (;24;) (type 0) (result i32) + i32.const 168755353) + (func (;25;) (type 0) (result i32) + i32.const 109071) + (func (;26;) (type 1) (result i64) + i64.const 1000000) + (func (;27;) (type 1) (result i64) + i64.const 1000) + (func (;28;) (type 1) (result i64) + i64.const 3078696982321561) + (func (;29;) (type 1) (result i64) + i64.const 109071) + (export \"i32.test\" (func 0)) + (export \"i32.umax\" (func 1)) + (export \"i32.smax\" (func 2)) + (export \"i32.neg_smax\" (func 3)) + (export \"i32.smin\" (func 4)) + (export \"i32.alt_smin\" (func 5)) + (export \"i32.inc_smin\" (func 6)) + (export \"i32.neg_zero\" (func 7)) + (export \"i32.not_octal\" (func 8)) + (export \"i32.unsigned_decimal\" (func 9)) + (export \"i32.plus_sign\" (func 10)) + (export \"i64.test\" (func 11)) + (export \"i64.umax\" (func 12)) + (export \"i64.smax\" (func 13)) + (export \"i64.neg_smax\" (func 14)) + (export \"i64.smin\" (func 15)) + (export \"i64.alt_smin\" (func 16)) + (export \"i64.inc_smin\" (func 17)) + (export \"i64.neg_zero\" (func 18)) + (export \"i64.not_octal\" (func 19)) + (export \"i64.unsigned_decimal\" (func 20)) + (export \"i64.plus_sign\" (func 21)) + (export \"i32-dec-sep1\" (func 22)) + (export \"i32-dec-sep2\" (func 23)) + (export \"i32-hex-sep1\" (func 24)) + (export \"i32-hex-sep2\" (func 25)) + (export \"i64-dec-sep1\" (func 26)) + (export \"i64-dec-sep2\" (func 27)) + (export \"i64-hex-sep1\" (func 28)) + (export \"i64-hex-sep2\" (func 29))) + "; + 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 37 +fn c1_l37_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l37_action_invoke"); + let result = instance.call("i32.test", &[]); + assert_eq!(result, Ok(Some(Value::I32(195940365 as i32)))); + result.map(|_| ()) +} + +// Line 38 +fn c2_l38_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l38_action_invoke"); + let result = instance.call("i32.umax", &[]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 39 +fn c3_l39_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l39_action_invoke"); + let result = instance.call("i32.smax", &[]); + assert_eq!(result, Ok(Some(Value::I32(2147483647 as i32)))); + result.map(|_| ()) +} + +// Line 40 +fn c4_l40_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l40_action_invoke"); + let result = instance.call("i32.neg_smax", &[]); + assert_eq!(result, Ok(Some(Value::I32(-2147483647 as i32)))); + result.map(|_| ()) +} + +// Line 41 +fn c5_l41_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l41_action_invoke"); + let result = instance.call("i32.smin", &[]); + assert_eq!(result, Ok(Some(Value::I32(-2147483648 as i32)))); + result.map(|_| ()) +} + +// Line 42 +fn c6_l42_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l42_action_invoke"); + let result = instance.call("i32.alt_smin", &[]); + assert_eq!(result, Ok(Some(Value::I32(-2147483648 as i32)))); + result.map(|_| ()) +} + +// Line 43 +fn c7_l43_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l43_action_invoke"); + let result = instance.call("i32.inc_smin", &[]); + assert_eq!(result, Ok(Some(Value::I32(-2147483647 as i32)))); + result.map(|_| ()) +} + +// Line 44 +fn c8_l44_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l44_action_invoke"); + let result = instance.call("i32.neg_zero", &[]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 45 +fn c9_l45_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l45_action_invoke"); + let result = instance.call("i32.not_octal", &[]); + assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); + result.map(|_| ()) +} + +// Line 46 +fn c10_l46_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c10_l46_action_invoke"); + let result = instance.call("i32.unsigned_decimal", &[]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 47 +fn c11_l47_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c11_l47_action_invoke"); + let result = instance.call("i32.plus_sign", &[]); + assert_eq!(result, Ok(Some(Value::I32(42 as i32)))); + result.map(|_| ()) +} + +// Line 49 +fn c12_l49_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c12_l49_action_invoke"); + let result = instance.call("i64.test", &[]); + assert_eq!(result, Ok(Some(Value::I64(913028331277281902 as i64)))); + result.map(|_| ()) +} + +// Line 50 +fn c13_l50_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c13_l50_action_invoke"); + let result = instance.call("i64.umax", &[]); + assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); + result.map(|_| ()) +} + +// Line 51 +fn c14_l51_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c14_l51_action_invoke"); + let result = instance.call("i64.smax", &[]); + assert_eq!(result, Ok(Some(Value::I64(9223372036854775807 as i64)))); + result.map(|_| ()) +} + +// Line 52 +fn c15_l52_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c15_l52_action_invoke"); + let result = instance.call("i64.neg_smax", &[]); + assert_eq!(result, Ok(Some(Value::I64(-9223372036854775807 as i64)))); + result.map(|_| ()) +} + +// Line 53 +fn c16_l53_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c16_l53_action_invoke"); + let result = instance.call("i64.smin", &[]); + assert_eq!(result, Ok(Some(Value::I64(-9223372036854775808 as i64)))); + result.map(|_| ()) +} + +// Line 54 +fn c17_l54_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c17_l54_action_invoke"); + let result = instance.call("i64.alt_smin", &[]); + assert_eq!(result, Ok(Some(Value::I64(-9223372036854775808 as i64)))); + result.map(|_| ()) +} + +// Line 55 +fn c18_l55_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c18_l55_action_invoke"); + let result = instance.call("i64.inc_smin", &[]); + assert_eq!(result, Ok(Some(Value::I64(-9223372036854775807 as i64)))); + result.map(|_| ()) +} + +// Line 56 +fn c19_l56_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c19_l56_action_invoke"); + let result = instance.call("i64.neg_zero", &[]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 57 +fn c20_l57_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c20_l57_action_invoke"); + let result = instance.call("i64.not_octal", &[]); + assert_eq!(result, Ok(Some(Value::I64(10 as i64)))); + result.map(|_| ()) +} + +// Line 58 +fn c21_l58_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c21_l58_action_invoke"); + let result = instance.call("i64.unsigned_decimal", &[]); + assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); + result.map(|_| ()) +} + +// Line 59 +fn c22_l59_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c22_l59_action_invoke"); + let result = instance.call("i64.plus_sign", &[]); + assert_eq!(result, Ok(Some(Value::I64(42 as i64)))); + result.map(|_| ()) +} + +// Line 61 +fn c23_l61_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c23_l61_action_invoke"); + let result = instance.call("i32-dec-sep1", &[]); + assert_eq!(result, Ok(Some(Value::I32(1000000 as i32)))); + result.map(|_| ()) +} + +// Line 62 +fn c24_l62_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c24_l62_action_invoke"); + let result = instance.call("i32-dec-sep2", &[]); + assert_eq!(result, Ok(Some(Value::I32(1000 as i32)))); + result.map(|_| ()) +} + +// Line 63 +fn c25_l63_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c25_l63_action_invoke"); + let result = instance.call("i32-hex-sep1", &[]); + assert_eq!(result, Ok(Some(Value::I32(168755353 as i32)))); + result.map(|_| ()) +} + +// Line 64 +fn c26_l64_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c26_l64_action_invoke"); + let result = instance.call("i32-hex-sep2", &[]); + assert_eq!(result, Ok(Some(Value::I32(109071 as i32)))); + result.map(|_| ()) +} + +// Line 66 +fn c27_l66_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c27_l66_action_invoke"); + let result = instance.call("i64-dec-sep1", &[]); + assert_eq!(result, Ok(Some(Value::I64(1000000 as i64)))); + result.map(|_| ()) +} + +// Line 67 +fn c28_l67_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c28_l67_action_invoke"); + let result = instance.call("i64-dec-sep2", &[]); + assert_eq!(result, Ok(Some(Value::I64(1000 as i64)))); + result.map(|_| ()) +} + +// Line 68 +fn c29_l68_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c29_l68_action_invoke"); + let result = instance.call("i64-hex-sep1", &[]); + assert_eq!(result, Ok(Some(Value::I64(3078696982321561 as i64)))); + result.map(|_| ()) +} + +// Line 69 +fn c30_l69_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c30_l69_action_invoke"); + let result = instance.call("i64-hex-sep2", &[]); + assert_eq!(result, Ok(Some(Value::I64(109071 as i64)))); + result.map(|_| ()) +} + +// Line 72 +#[test] +fn c31_l72_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 51, 50, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 95, 49, 48, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 76 +#[test] +fn c32_l76_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 51, 50, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 43, 95, 49, 48, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 80 +#[test] +fn c33_l80_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 51, 50, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 45, 95, 49, 48, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 84 +#[test] +fn c34_l84_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 51, 50, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 57, 57, 95, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 88 +#[test] +fn c35_l88_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 51, 50, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 49, 95, 95, 48, 48, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 92 +#[test] +fn c36_l92_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 51, 50, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 95, 48, 120, 49, 48, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 96 +#[test] +fn c37_l96_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 51, 50, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 95, 120, 49, 48, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 100 +#[test] +fn c38_l100_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 51, 50, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 95, 49, 48, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 104 +#[test] +fn c39_l104_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 51, 50, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 48, 48, 95, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 108 +#[test] +fn c40_l108_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 51, 50, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 120, 102, 102, 95, 95, 102, 102, 102, 102, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 113 +#[test] +fn c41_l113_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 54, 52, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 95, 49, 48, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 117 +#[test] +fn c42_l117_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 54, 52, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 43, 95, 49, 48, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 121 +#[test] +fn c43_l121_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 54, 52, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 45, 95, 49, 48, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 125 +#[test] +fn c44_l125_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 54, 52, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 57, 57, 95, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 129 +#[test] +fn c45_l129_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 54, 52, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 49, 95, 95, 48, 48, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 133 +#[test] +fn c46_l133_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 54, 52, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 95, 48, 120, 49, 48, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 137 +#[test] +fn c47_l137_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 54, 52, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 95, 120, 49, 48, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 141 +#[test] +fn c48_l141_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 54, 52, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 95, 49, 48, 48, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 145 +#[test] +fn c49_l145_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 54, 52, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 48, 48, 95, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 149 +#[test] +fn c50_l149_assert_malformed() { + let wasm_binary = [40, 103, 108, 111, 98, 97, 108, 32, 105, 54, 52, 32, 40, 105, 54, 52, 46, 99, 111, 110, 115, 116, 32, 48, 120, 102, 102, 95, 95, 102, 102, 102, 102, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l37_action_invoke(&mut instance); + c2_l38_action_invoke(&mut instance); + c3_l39_action_invoke(&mut instance); + c4_l40_action_invoke(&mut instance); + c5_l41_action_invoke(&mut instance); + c6_l42_action_invoke(&mut instance); + c7_l43_action_invoke(&mut instance); + c8_l44_action_invoke(&mut instance); + c9_l45_action_invoke(&mut instance); + c10_l46_action_invoke(&mut instance); + c11_l47_action_invoke(&mut instance); + c12_l49_action_invoke(&mut instance); + c13_l50_action_invoke(&mut instance); + c14_l51_action_invoke(&mut instance); + c15_l52_action_invoke(&mut instance); + c16_l53_action_invoke(&mut instance); + c17_l54_action_invoke(&mut instance); + c18_l55_action_invoke(&mut instance); + c19_l56_action_invoke(&mut instance); + c20_l57_action_invoke(&mut instance); + c21_l58_action_invoke(&mut instance); + c22_l59_action_invoke(&mut instance); + c23_l61_action_invoke(&mut instance); + c24_l62_action_invoke(&mut instance); + c25_l63_action_invoke(&mut instance); + c26_l64_action_invoke(&mut instance); + c27_l66_action_invoke(&mut instance); + c28_l67_action_invoke(&mut instance); + c29_l68_action_invoke(&mut instance); + c30_l69_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/labels.rs b/lib/runtime/tests/spectests/labels.rs new file mode 100644 index 000000000..8c0cbe039 --- /dev/null +++ b/lib/runtime/tests/spectests/labels.rs @@ -0,0 +1,723 @@ +// 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/labels.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 1 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func (result i32))) + (type (;1;) (func (param i32) (result i32))) + (func (;0;) (type 0) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + br 0 (;@1;) + i32.const 0 + end) + (func (;1;) (type 0) (result i32) + (local i32) + i32.const 0 + set_local 0 + block (result i32) ;; label = @1 + loop (result i32) ;; label = @2 + get_local 0 + i32.const 1 + i32.add + set_local 0 + get_local 0 + i32.const 5 + i32.eq + if ;; label = @3 + get_local 0 + br 2 (;@1;) + end + br 0 (;@2;) + end + end) + (func (;2;) (type 0) (result i32) + (local i32) + i32.const 0 + set_local 0 + block (result i32) ;; label = @1 + loop (result i32) ;; label = @2 + get_local 0 + i32.const 1 + i32.add + set_local 0 + get_local 0 + i32.const 5 + i32.eq + if ;; label = @3 + br 1 (;@2;) + end + get_local 0 + i32.const 8 + i32.eq + if ;; label = @3 + get_local 0 + br 2 (;@1;) + end + get_local 0 + i32.const 1 + i32.add + set_local 0 + br 0 (;@2;) + end + end) + (func (;3;) (type 0) (result i32) + (local i32) + i32.const 0 + set_local 0 + block (result i32) ;; label = @1 + loop (result i32) ;; label = @2 + get_local 0 + i32.const 1 + i32.add + set_local 0 + get_local 0 + i32.const 5 + i32.eq + if ;; label = @3 + get_local 0 + br 2 (;@1;) + end + get_local 0 + end + end) + (func (;4;) (type 1) (param i32) (result i32) + (local i32) + i32.const 1 + set_local 1 + block (result i32) ;; label = @1 + loop (result i32) ;; label = @2 + get_local 1 + get_local 1 + i32.add + set_local 1 + get_local 1 + get_local 0 + i32.gt_u + if ;; label = @3 + get_local 1 + br 2 (;@1;) + end + br 0 (;@2;) + end + end) + (func (;5;) (type 0) (result i32) + loop (result i32) ;; label = @1 + i32.const 1 + end + i32.const 1 + i32.add) + (func (;6;) (type 0) (result i32) + loop (result i32) ;; label = @1 + i32.const 0 + br_if 0 (;@1;) + i32.const 3 + end) + (func (;7;) (type 0) (result i32) + (local i32) + i32.const 0 + set_local 0 + block ;; label = @1 + i32.const 1 + if ;; label = @2 + br 0 (;@2;) + i32.const 666 + set_local 0 + end + get_local 0 + i32.const 1 + i32.add + set_local 0 + i32.const 1 + if ;; label = @2 + br 0 (;@2;) + i32.const 666 + set_local 0 + else + i32.const 888 + set_local 0 + end + get_local 0 + i32.const 1 + i32.add + set_local 0 + i32.const 1 + if ;; label = @2 + br 0 (;@2;) + i32.const 666 + set_local 0 + else + i32.const 888 + set_local 0 + end + get_local 0 + i32.const 1 + i32.add + set_local 0 + i32.const 0 + if ;; label = @2 + i32.const 888 + set_local 0 + else + br 0 (;@2;) + i32.const 666 + set_local 0 + end + get_local 0 + i32.const 1 + i32.add + set_local 0 + i32.const 0 + if ;; label = @2 + i32.const 888 + set_local 0 + else + br 0 (;@2;) + i32.const 666 + set_local 0 + end + get_local 0 + i32.const 1 + i32.add + set_local 0 + end + get_local 0) + (func (;8;) (type 0) (result i32) + (local i32) + i32.const 0 + set_local 0 + block ;; label = @1 + i32.const 1 + if ;; label = @2 + br 0 (;@2;) + i32.const 666 + set_local 0 + end + get_local 0 + i32.const 1 + i32.add + set_local 0 + i32.const 1 + if ;; label = @2 + br 0 (;@2;) + i32.const 666 + set_local 0 + else + i32.const 888 + set_local 0 + end + get_local 0 + i32.const 1 + i32.add + set_local 0 + i32.const 1 + if ;; label = @2 + br 0 (;@2;) + i32.const 666 + set_local 0 + else + i32.const 888 + set_local 0 + end + get_local 0 + i32.const 1 + i32.add + set_local 0 + i32.const 0 + if ;; label = @2 + i32.const 888 + set_local 0 + else + br 0 (;@2;) + i32.const 666 + set_local 0 + end + get_local 0 + i32.const 1 + i32.add + set_local 0 + i32.const 0 + if ;; label = @2 + i32.const 888 + set_local 0 + else + br 0 (;@2;) + i32.const 666 + set_local 0 + end + get_local 0 + i32.const 1 + i32.add + set_local 0 + end + get_local 0) + (func (;9;) (type 1) (param i32) (result i32) + block (result i32) ;; label = @1 + i32.const 10 + block (result i32) ;; label = @2 + block ;; label = @3 + block ;; label = @4 + block ;; label = @5 + block ;; label = @6 + block ;; label = @7 + get_local 0 + br_table 4 (;@3;) 0 (;@7;) 1 (;@6;) 2 (;@5;) 3 (;@4;) + end + end + i32.const 2 + br 3 (;@2;) + end + i32.const 3 + br 3 (;@1;) + end + end + i32.const 5 + end + i32.mul + end) + (func (;10;) (type 1) (param i32) (result i32) + block ;; label = @1 + block ;; label = @2 + block ;; label = @3 + get_local 0 + br_table 0 (;@3;) 1 (;@2;) + br 2 (;@1;) + end + i32.const 0 + return + end + end + i32.const 2) + (func (;11;) (type 0) (result i32) + (local i32) + i32.const 0 + set_local 0 + block (result i32) ;; label = @1 + block ;; label = @2 + i32.const 0 + br_if 0 (;@2;) + get_local 0 + i32.const 1 + i32.or + set_local 0 + i32.const 1 + br_if 0 (;@2;) + get_local 0 + i32.const 2 + i32.or + set_local 0 + end + block (result i32) ;; label = @2 + get_local 0 + i32.const 4 + i32.or + set_local 0 + get_local 0 + end + i32.const 0 + br_if 0 (;@1;) + drop + get_local 0 + i32.const 8 + i32.or + set_local 0 + block (result i32) ;; label = @2 + get_local 0 + i32.const 16 + i32.or + set_local 0 + get_local 0 + end + i32.const 1 + br_if 0 (;@1;) + drop + get_local 0 + i32.const 32 + i32.or + set_local 0 + get_local 0 + end) + (func (;12;) (type 0) (result i32) + block (result i32) ;; label = @1 + block (result i32) ;; label = @2 + i32.const 1 + br 0 (;@2;) + end + i32.const 1 + br_if 0 (;@1;) + drop + i32.const 1 + end) + (func (;13;) (type 0) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + if ;; label = @2 + block (result i32) ;; label = @3 + i32.const 1 + br 0 (;@3;) + end + br 1 (;@1;) + end + i32.const 1 + end) + (func (;14;) (type 0) (result i32) + (local i32) + block (result i32) ;; label = @1 + block (result i32) ;; label = @2 + i32.const 1 + set_local 0 + get_local 0 + end + block (result i32) ;; label = @2 + i32.const 2 + set_local 0 + get_local 0 + end + br_if 0 (;@1;) + drop + i32.const 0 + end + i32.const 0 + i32.add + drop + get_local 0) + (func (;15;) (type 0) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + if ;; label = @2 + block (result i32) ;; label = @3 + i32.const 1 + br 0 (;@3;) + end + br 1 (;@1;) + else + block ;; label = @3 + block (result i32) ;; label = @4 + i32.const 1 + br 0 (;@4;) + end + drop + end + end + i32.const 1 + end) + (func (;16;) (type 0) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + br 0 (;@1;) + i32.const 2 + i32.xor + end) + (func (;17;) (type 0) (result i32) + block (result i32) ;; label = @1 + block (result i32) ;; label = @2 + i32.const 2 + end + block (result i32) ;; label = @2 + i32.const 3 + br 0 (;@2;) + end + i32.add + end) + (export \"block\" (func 0)) + (export \"loop1\" (func 1)) + (export \"loop2\" (func 2)) + (export \"loop3\" (func 3)) + (export \"loop4\" (func 4)) + (export \"loop5\" (func 5)) + (export \"loop6\" (func 6)) + (export \"if\" (func 7)) + (export \"if2\" (func 8)) + (export \"switch\" (func 9)) + (export \"return\" (func 10)) + (export \"br_if0\" (func 11)) + (export \"br_if1\" (func 12)) + (export \"br_if2\" (func 13)) + (export \"br_if3\" (func 14)) + (export \"br\" (func 15)) + (export \"shadowing\" (func 16)) + (export \"redefinition\" (func 17))) + "; + 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 284 +fn c1_l284_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l284_action_invoke"); + let result = instance.call("block", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 285 +fn c2_l285_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l285_action_invoke"); + let result = instance.call("loop1", &[]); + assert_eq!(result, Ok(Some(Value::I32(5 as i32)))); + result.map(|_| ()) +} + +// Line 286 +fn c3_l286_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l286_action_invoke"); + let result = instance.call("loop2", &[]); + assert_eq!(result, Ok(Some(Value::I32(8 as i32)))); + result.map(|_| ()) +} + +// Line 287 +fn c4_l287_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l287_action_invoke"); + let result = instance.call("loop3", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 288 +fn c5_l288_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l288_action_invoke"); + let result = instance.call("loop4", &[Value::I32(8 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(16 as i32)))); + result.map(|_| ()) +} + +// Line 289 +fn c6_l289_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l289_action_invoke"); + let result = instance.call("loop5", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 290 +fn c7_l290_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l290_action_invoke"); + let result = instance.call("loop6", &[]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 291 +fn c8_l291_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l291_action_invoke"); + let result = instance.call("if", &[]); + assert_eq!(result, Ok(Some(Value::I32(5 as i32)))); + result.map(|_| ()) +} + +// Line 292 +fn c9_l292_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l292_action_invoke"); + let result = instance.call("if2", &[]); + assert_eq!(result, Ok(Some(Value::I32(5 as i32)))); + result.map(|_| ()) +} + +// Line 293 +fn c10_l293_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c10_l293_action_invoke"); + let result = instance.call("switch", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(50 as i32)))); + result.map(|_| ()) +} + +// Line 294 +fn c11_l294_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c11_l294_action_invoke"); + let result = instance.call("switch", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(20 as i32)))); + result.map(|_| ()) +} + +// Line 295 +fn c12_l295_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c12_l295_action_invoke"); + let result = instance.call("switch", &[Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(20 as i32)))); + result.map(|_| ()) +} + +// Line 296 +fn c13_l296_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c13_l296_action_invoke"); + let result = instance.call("switch", &[Value::I32(3 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 297 +fn c14_l297_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c14_l297_action_invoke"); + let result = instance.call("switch", &[Value::I32(4 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(50 as i32)))); + result.map(|_| ()) +} + +// Line 298 +fn c15_l298_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c15_l298_action_invoke"); + let result = instance.call("switch", &[Value::I32(5 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(50 as i32)))); + result.map(|_| ()) +} + +// Line 299 +fn c16_l299_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c16_l299_action_invoke"); + let result = instance.call("return", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 300 +fn c17_l300_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c17_l300_action_invoke"); + let result = instance.call("return", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 301 +fn c18_l301_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c18_l301_action_invoke"); + let result = instance.call("return", &[Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 302 +fn c19_l302_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c19_l302_action_invoke"); + let result = instance.call("br_if0", &[]); + assert_eq!(result, Ok(Some(Value::I32(29 as i32)))); + result.map(|_| ()) +} + +// Line 303 +fn c20_l303_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c20_l303_action_invoke"); + let result = instance.call("br_if1", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 304 +fn c21_l304_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c21_l304_action_invoke"); + let result = instance.call("br_if2", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 305 +fn c22_l305_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c22_l305_action_invoke"); + let result = instance.call("br_if3", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 306 +fn c23_l306_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c23_l306_action_invoke"); + let result = instance.call("br", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 307 +fn c24_l307_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c24_l307_action_invoke"); + let result = instance.call("shadowing", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 308 +fn c25_l308_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c25_l308_action_invoke"); + let result = instance.call("redefinition", &[]); + assert_eq!(result, Ok(Some(Value::I32(5 as i32)))); + result.map(|_| ()) +} + +// Line 311 +#[test] +fn c26_l311_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 64, 65, 1, 13, 0, 140, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 315 +#[test] +fn c27_l315_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 64, 67, 0, 0, 0, 0, 65, 1, 13, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 319 +#[test] +fn c28_l319_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 64, 67, 0, 0, 0, 0, 65, 1, 13, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l284_action_invoke(&mut instance); + c2_l285_action_invoke(&mut instance); + c3_l286_action_invoke(&mut instance); + c4_l287_action_invoke(&mut instance); + c5_l288_action_invoke(&mut instance); + c6_l289_action_invoke(&mut instance); + c7_l290_action_invoke(&mut instance); + c8_l291_action_invoke(&mut instance); + c9_l292_action_invoke(&mut instance); + c10_l293_action_invoke(&mut instance); + c11_l294_action_invoke(&mut instance); + c12_l295_action_invoke(&mut instance); + c13_l296_action_invoke(&mut instance); + c14_l297_action_invoke(&mut instance); + c15_l298_action_invoke(&mut instance); + c16_l299_action_invoke(&mut instance); + c17_l300_action_invoke(&mut instance); + c18_l301_action_invoke(&mut instance); + c19_l302_action_invoke(&mut instance); + c20_l303_action_invoke(&mut instance); + c21_l304_action_invoke(&mut instance); + c22_l305_action_invoke(&mut instance); + c23_l306_action_invoke(&mut instance); + c24_l307_action_invoke(&mut instance); + c25_l308_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/left_to_right.rs b/lib/runtime/tests/spectests/left_to_right.rs new file mode 100644 index 000000000..9e5d8d94d --- /dev/null +++ b/lib/runtime/tests/spectests/left_to_right.rs @@ -0,0 +1,1837 @@ +// 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/left_to_right.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 1 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func (param i32 i32) (result i32))) + (type (;1;) (func (param i64 i64) (result i32))) + (type (;2;) (func (param f32 f32) (result i32))) + (type (;3;) (func (param f64 f64) (result i32))) + (type (;4;) (func)) + (type (;5;) (func (result i32))) + (type (;6;) (func (result i64))) + (type (;7;) (func (result f32))) + (type (;8;) (func (result f64))) + (type (;9;) (func (param i32 i32))) + (type (;10;) (func (param i64 i64))) + (type (;11;) (func (param f32 f32))) + (type (;12;) (func (param f64 f64))) + (func (;0;) (type 0) (param i32 i32) (result i32) + i32.const -1) + (func (;1;) (type 0) (param i32 i32) (result i32) + i32.const -2) + (func (;2;) (type 1) (param i64 i64) (result i32) + i32.const -1) + (func (;3;) (type 1) (param i64 i64) (result i32) + i32.const -2) + (func (;4;) (type 2) (param f32 f32) (result i32) + i32.const -1) + (func (;5;) (type 2) (param f32 f32) (result i32) + i32.const -2) + (func (;6;) (type 3) (param f64 f64) (result i32) + i32.const -1) + (func (;7;) (type 3) (param f64 f64) (result i32) + i32.const -2) + (func (;8;) (type 4) + i32.const 8 + i32.const 0 + i32.store) + (func (;9;) (type 4) + i32.const 11 + i32.const 10 + i32.load8_u + i32.store8 + i32.const 10 + i32.const 9 + i32.load8_u + i32.store8 + i32.const 9 + i32.const 8 + i32.load8_u + i32.store8 + i32.const 8 + i32.const -3 + i32.store8) + (func (;10;) (type 5) (result i32) + i32.const 8 + i32.load) + (func (;11;) (type 5) (result i32) + call 9 + i32.const 8 + i32.const 1 + i32.store8 + i32.const 0) + (func (;12;) (type 5) (result i32) + call 9 + i32.const 8 + i32.const 2 + i32.store8 + i32.const 1) + (func (;13;) (type 5) (result i32) + call 9 + i32.const 8 + i32.const 3 + i32.store8 + i32.const 1) + (func (;14;) (type 5) (result i32) + call 9 + i32.const 8 + i32.const 4 + i32.store8 + i32.const 0) + (func (;15;) (type 5) (result i32) + call 9 + i32.const 8 + i32.const 5 + i32.store8 + i32.const 0) + (func (;16;) (type 6) (result i64) + call 9 + i32.const 8 + i32.const 1 + i32.store8 + i64.const 0) + (func (;17;) (type 6) (result i64) + call 9 + i32.const 8 + i32.const 2 + i32.store8 + i64.const 1) + (func (;18;) (type 6) (result i64) + call 9 + i32.const 8 + i32.const 3 + i32.store8 + i64.const 1) + (func (;19;) (type 5) (result i32) + call 9 + i32.const 8 + i32.const 4 + i32.store8 + i32.const 2) + (func (;20;) (type 5) (result i32) + call 9 + i32.const 8 + i32.const 5 + i32.store8 + i32.const 0) + (func (;21;) (type 7) (result f32) + call 9 + i32.const 8 + i32.const 1 + i32.store8 + f32.const 0x0p+0 (;=0;)) + (func (;22;) (type 7) (result f32) + call 9 + i32.const 8 + i32.const 2 + i32.store8 + f32.const 0x1p+0 (;=1;)) + (func (;23;) (type 7) (result f32) + call 9 + i32.const 8 + i32.const 3 + i32.store8 + f32.const 0x1p+0 (;=1;)) + (func (;24;) (type 5) (result i32) + call 9 + i32.const 8 + i32.const 4 + i32.store8 + i32.const 4) + (func (;25;) (type 5) (result i32) + call 9 + i32.const 8 + i32.const 5 + i32.store8 + i32.const 0) + (func (;26;) (type 8) (result f64) + call 9 + i32.const 8 + i32.const 1 + i32.store8 + f64.const 0x0p+0 (;=0;)) + (func (;27;) (type 8) (result f64) + call 9 + i32.const 8 + i32.const 2 + i32.store8 + f64.const 0x1p+0 (;=1;)) + (func (;28;) (type 8) (result f64) + call 9 + i32.const 8 + i32.const 3 + i32.store8 + f64.const 0x1p+0 (;=1;)) + (func (;29;) (type 5) (result i32) + call 9 + i32.const 8 + i32.const 4 + i32.store8 + i32.const 6) + (func (;30;) (type 5) (result i32) + call 9 + i32.const 8 + i32.const 5 + i32.store8 + i32.const 0) + (func (;31;) (type 9) (param i32 i32)) + (func (;32;) (type 10) (param i64 i64)) + (func (;33;) (type 11) (param f32 f32)) + (func (;34;) (type 12) (param f64 f64)) + (func (;35;) (type 5) (result i32) + call 8 + call 11 + call 12 + i32.add + drop + call 10) + (func (;36;) (type 5) (result i32) + call 8 + call 11 + call 12 + i32.sub + drop + call 10) + (func (;37;) (type 5) (result i32) + call 8 + call 11 + call 12 + i32.mul + drop + call 10) + (func (;38;) (type 5) (result i32) + call 8 + call 11 + call 12 + i32.div_s + drop + call 10) + (func (;39;) (type 5) (result i32) + call 8 + call 11 + call 12 + i32.div_u + drop + call 10) + (func (;40;) (type 5) (result i32) + call 8 + call 11 + call 12 + i32.rem_s + drop + call 10) + (func (;41;) (type 5) (result i32) + call 8 + call 11 + call 12 + i32.rem_u + drop + call 10) + (func (;42;) (type 5) (result i32) + call 8 + call 11 + call 12 + i32.and + drop + call 10) + (func (;43;) (type 5) (result i32) + call 8 + call 11 + call 12 + i32.or + drop + call 10) + (func (;44;) (type 5) (result i32) + call 8 + call 11 + call 12 + i32.xor + drop + call 10) + (func (;45;) (type 5) (result i32) + call 8 + call 11 + call 12 + i32.shl + drop + call 10) + (func (;46;) (type 5) (result i32) + call 8 + call 11 + call 12 + i32.shr_u + drop + call 10) + (func (;47;) (type 5) (result i32) + call 8 + call 11 + call 12 + i32.shr_s + drop + call 10) + (func (;48;) (type 5) (result i32) + call 8 + call 11 + call 12 + i32.eq + drop + call 10) + (func (;49;) (type 5) (result i32) + call 8 + call 11 + call 12 + i32.ne + drop + call 10) + (func (;50;) (type 5) (result i32) + call 8 + call 11 + call 12 + i32.lt_s + drop + call 10) + (func (;51;) (type 5) (result i32) + call 8 + call 11 + call 12 + i32.le_s + drop + call 10) + (func (;52;) (type 5) (result i32) + call 8 + call 11 + call 12 + i32.lt_u + drop + call 10) + (func (;53;) (type 5) (result i32) + call 8 + call 11 + call 12 + i32.le_u + drop + call 10) + (func (;54;) (type 5) (result i32) + call 8 + call 11 + call 12 + i32.gt_s + drop + call 10) + (func (;55;) (type 5) (result i32) + call 8 + call 11 + call 12 + i32.ge_s + drop + call 10) + (func (;56;) (type 5) (result i32) + call 8 + call 11 + call 12 + i32.gt_u + drop + call 10) + (func (;57;) (type 5) (result i32) + call 8 + call 11 + call 12 + i32.ge_u + drop + call 10) + (func (;58;) (type 5) (result i32) + call 8 + call 11 + call 12 + i32.store + call 10) + (func (;59;) (type 5) (result i32) + call 8 + call 11 + call 12 + i32.store8 + call 10) + (func (;60;) (type 5) (result i32) + call 8 + call 11 + call 12 + i32.store16 + call 10) + (func (;61;) (type 5) (result i32) + call 8 + call 11 + call 12 + call 31 + call 10) + (func (;62;) (type 5) (result i32) + call 8 + call 11 + call 12 + call 14 + call_indirect (type 0) + drop + call 10) + (func (;63;) (type 5) (result i32) + call 8 + call 11 + call 12 + call 15 + select + drop + call 10) + (func (;64;) (type 5) (result i32) + call 8 + call 16 + call 17 + i64.add + drop + call 10) + (func (;65;) (type 5) (result i32) + call 8 + call 16 + call 17 + i64.sub + drop + call 10) + (func (;66;) (type 5) (result i32) + call 8 + call 16 + call 17 + i64.mul + drop + call 10) + (func (;67;) (type 5) (result i32) + call 8 + call 16 + call 17 + i64.div_s + drop + call 10) + (func (;68;) (type 5) (result i32) + call 8 + call 16 + call 17 + i64.div_u + drop + call 10) + (func (;69;) (type 5) (result i32) + call 8 + call 16 + call 17 + i64.rem_s + drop + call 10) + (func (;70;) (type 5) (result i32) + call 8 + call 16 + call 17 + i64.rem_u + drop + call 10) + (func (;71;) (type 5) (result i32) + call 8 + call 16 + call 17 + i64.and + drop + call 10) + (func (;72;) (type 5) (result i32) + call 8 + call 16 + call 17 + i64.or + drop + call 10) + (func (;73;) (type 5) (result i32) + call 8 + call 16 + call 17 + i64.xor + drop + call 10) + (func (;74;) (type 5) (result i32) + call 8 + call 16 + call 17 + i64.shl + drop + call 10) + (func (;75;) (type 5) (result i32) + call 8 + call 16 + call 17 + i64.shr_u + drop + call 10) + (func (;76;) (type 5) (result i32) + call 8 + call 16 + call 17 + i64.shr_s + drop + call 10) + (func (;77;) (type 5) (result i32) + call 8 + call 16 + call 17 + i64.eq + drop + call 10) + (func (;78;) (type 5) (result i32) + call 8 + call 16 + call 17 + i64.ne + drop + call 10) + (func (;79;) (type 5) (result i32) + call 8 + call 16 + call 17 + i64.lt_s + drop + call 10) + (func (;80;) (type 5) (result i32) + call 8 + call 16 + call 17 + i64.le_s + drop + call 10) + (func (;81;) (type 5) (result i32) + call 8 + call 16 + call 17 + i64.lt_u + drop + call 10) + (func (;82;) (type 5) (result i32) + call 8 + call 16 + call 17 + i64.le_u + drop + call 10) + (func (;83;) (type 5) (result i32) + call 8 + call 16 + call 17 + i64.gt_s + drop + call 10) + (func (;84;) (type 5) (result i32) + call 8 + call 16 + call 17 + i64.ge_s + drop + call 10) + (func (;85;) (type 5) (result i32) + call 8 + call 16 + call 17 + i64.gt_u + drop + call 10) + (func (;86;) (type 5) (result i32) + call 8 + call 16 + call 17 + i64.ge_u + drop + call 10) + (func (;87;) (type 5) (result i32) + call 8 + call 11 + call 17 + i64.store + call 10) + (func (;88;) (type 5) (result i32) + call 8 + call 11 + call 17 + i64.store8 + call 10) + (func (;89;) (type 5) (result i32) + call 8 + call 11 + call 17 + i64.store16 + call 10) + (func (;90;) (type 5) (result i32) + call 8 + call 11 + call 17 + i64.store32 + call 10) + (func (;91;) (type 5) (result i32) + call 8 + call 16 + call 17 + call 32 + call 10) + (func (;92;) (type 5) (result i32) + call 8 + call 16 + call 17 + call 19 + call_indirect (type 1) + drop + call 10) + (func (;93;) (type 5) (result i32) + call 8 + call 16 + call 17 + call 20 + select + drop + call 10) + (func (;94;) (type 5) (result i32) + call 8 + call 21 + call 22 + f32.add + drop + call 10) + (func (;95;) (type 5) (result i32) + call 8 + call 21 + call 22 + f32.sub + drop + call 10) + (func (;96;) (type 5) (result i32) + call 8 + call 21 + call 22 + f32.mul + drop + call 10) + (func (;97;) (type 5) (result i32) + call 8 + call 21 + call 22 + f32.div + drop + call 10) + (func (;98;) (type 5) (result i32) + call 8 + call 21 + call 22 + f32.copysign + drop + call 10) + (func (;99;) (type 5) (result i32) + call 8 + call 21 + call 22 + f32.eq + drop + call 10) + (func (;100;) (type 5) (result i32) + call 8 + call 21 + call 22 + f32.ne + drop + call 10) + (func (;101;) (type 5) (result i32) + call 8 + call 21 + call 22 + f32.lt + drop + call 10) + (func (;102;) (type 5) (result i32) + call 8 + call 21 + call 22 + f32.le + drop + call 10) + (func (;103;) (type 5) (result i32) + call 8 + call 21 + call 22 + f32.gt + drop + call 10) + (func (;104;) (type 5) (result i32) + call 8 + call 21 + call 22 + f32.ge + drop + call 10) + (func (;105;) (type 5) (result i32) + call 8 + call 21 + call 22 + f32.min + drop + call 10) + (func (;106;) (type 5) (result i32) + call 8 + call 21 + call 22 + f32.max + drop + call 10) + (func (;107;) (type 5) (result i32) + call 8 + call 11 + call 22 + f32.store + call 10) + (func (;108;) (type 5) (result i32) + call 8 + call 21 + call 22 + call 33 + call 10) + (func (;109;) (type 5) (result i32) + call 8 + call 21 + call 22 + call 24 + call_indirect (type 2) + drop + call 10) + (func (;110;) (type 5) (result i32) + call 8 + call 21 + call 22 + call 25 + select + drop + call 10) + (func (;111;) (type 5) (result i32) + call 8 + call 26 + call 27 + f64.add + drop + call 10) + (func (;112;) (type 5) (result i32) + call 8 + call 26 + call 27 + f64.sub + drop + call 10) + (func (;113;) (type 5) (result i32) + call 8 + call 26 + call 27 + f64.mul + drop + call 10) + (func (;114;) (type 5) (result i32) + call 8 + call 26 + call 27 + f64.div + drop + call 10) + (func (;115;) (type 5) (result i32) + call 8 + call 26 + call 27 + f64.copysign + drop + call 10) + (func (;116;) (type 5) (result i32) + call 8 + call 26 + call 27 + f64.eq + drop + call 10) + (func (;117;) (type 5) (result i32) + call 8 + call 26 + call 27 + f64.ne + drop + call 10) + (func (;118;) (type 5) (result i32) + call 8 + call 26 + call 27 + f64.lt + drop + call 10) + (func (;119;) (type 5) (result i32) + call 8 + call 26 + call 27 + f64.le + drop + call 10) + (func (;120;) (type 5) (result i32) + call 8 + call 26 + call 27 + f64.gt + drop + call 10) + (func (;121;) (type 5) (result i32) + call 8 + call 26 + call 27 + f64.ge + drop + call 10) + (func (;122;) (type 5) (result i32) + call 8 + call 26 + call 27 + f64.min + drop + call 10) + (func (;123;) (type 5) (result i32) + call 8 + call 26 + call 27 + f64.max + drop + call 10) + (func (;124;) (type 5) (result i32) + call 8 + call 11 + call 27 + f64.store + call 10) + (func (;125;) (type 5) (result i32) + call 8 + call 26 + call 27 + call 34 + call 10) + (func (;126;) (type 5) (result i32) + call 8 + call 26 + call 27 + call 29 + call_indirect (type 3) + drop + call 10) + (func (;127;) (type 5) (result i32) + call 8 + call 26 + call 27 + call 30 + select + drop + call 10) + (func (;128;) (type 5) (result i32) + block (result i32) ;; label = @1 + call 8 + call 11 + call 12 + i32.const 0 + i32.and + br_if 0 (;@1;) + drop + call 10 + end) + (func (;129;) (type 5) (result i32) + block (result i32) ;; label = @1 + call 8 + block (result i32) ;; label = @2 + call 11 + call 12 + br_table 1 (;@1;) 0 (;@2;) + end + drop + call 10 + end) + (table (;0;) 8 8 anyfunc) + (memory (;0;) 1) + (export \"i32_add\" (func 35)) + (export \"i32_sub\" (func 36)) + (export \"i32_mul\" (func 37)) + (export \"i32_div_s\" (func 38)) + (export \"i32_div_u\" (func 39)) + (export \"i32_rem_s\" (func 40)) + (export \"i32_rem_u\" (func 41)) + (export \"i32_and\" (func 42)) + (export \"i32_or\" (func 43)) + (export \"i32_xor\" (func 44)) + (export \"i32_shl\" (func 45)) + (export \"i32_shr_u\" (func 46)) + (export \"i32_shr_s\" (func 47)) + (export \"i32_eq\" (func 48)) + (export \"i32_ne\" (func 49)) + (export \"i32_lt_s\" (func 50)) + (export \"i32_le_s\" (func 51)) + (export \"i32_lt_u\" (func 52)) + (export \"i32_le_u\" (func 53)) + (export \"i32_gt_s\" (func 54)) + (export \"i32_ge_s\" (func 55)) + (export \"i32_gt_u\" (func 56)) + (export \"i32_ge_u\" (func 57)) + (export \"i32_store\" (func 58)) + (export \"i32_store8\" (func 59)) + (export \"i32_store16\" (func 60)) + (export \"i32_call\" (func 61)) + (export \"i32_call_indirect\" (func 62)) + (export \"i32_select\" (func 63)) + (export \"i64_add\" (func 64)) + (export \"i64_sub\" (func 65)) + (export \"i64_mul\" (func 66)) + (export \"i64_div_s\" (func 67)) + (export \"i64_div_u\" (func 68)) + (export \"i64_rem_s\" (func 69)) + (export \"i64_rem_u\" (func 70)) + (export \"i64_and\" (func 71)) + (export \"i64_or\" (func 72)) + (export \"i64_xor\" (func 73)) + (export \"i64_shl\" (func 74)) + (export \"i64_shr_u\" (func 75)) + (export \"i64_shr_s\" (func 76)) + (export \"i64_eq\" (func 77)) + (export \"i64_ne\" (func 78)) + (export \"i64_lt_s\" (func 79)) + (export \"i64_le_s\" (func 80)) + (export \"i64_lt_u\" (func 81)) + (export \"i64_le_u\" (func 82)) + (export \"i64_gt_s\" (func 83)) + (export \"i64_ge_s\" (func 84)) + (export \"i64_gt_u\" (func 85)) + (export \"i64_ge_u\" (func 86)) + (export \"i64_store\" (func 87)) + (export \"i64_store8\" (func 88)) + (export \"i64_store16\" (func 89)) + (export \"i64_store32\" (func 90)) + (export \"i64_call\" (func 91)) + (export \"i64_call_indirect\" (func 92)) + (export \"i64_select\" (func 93)) + (export \"f32_add\" (func 94)) + (export \"f32_sub\" (func 95)) + (export \"f32_mul\" (func 96)) + (export \"f32_div\" (func 97)) + (export \"f32_copysign\" (func 98)) + (export \"f32_eq\" (func 99)) + (export \"f32_ne\" (func 100)) + (export \"f32_lt\" (func 101)) + (export \"f32_le\" (func 102)) + (export \"f32_gt\" (func 103)) + (export \"f32_ge\" (func 104)) + (export \"f32_min\" (func 105)) + (export \"f32_max\" (func 106)) + (export \"f32_store\" (func 107)) + (export \"f32_call\" (func 108)) + (export \"f32_call_indirect\" (func 109)) + (export \"f32_select\" (func 110)) + (export \"f64_add\" (func 111)) + (export \"f64_sub\" (func 112)) + (export \"f64_mul\" (func 113)) + (export \"f64_div\" (func 114)) + (export \"f64_copysign\" (func 115)) + (export \"f64_eq\" (func 116)) + (export \"f64_ne\" (func 117)) + (export \"f64_lt\" (func 118)) + (export \"f64_le\" (func 119)) + (export \"f64_gt\" (func 120)) + (export \"f64_ge\" (func 121)) + (export \"f64_min\" (func 122)) + (export \"f64_max\" (func 123)) + (export \"f64_store\" (func 124)) + (export \"f64_call\" (func 125)) + (export \"f64_call_indirect\" (func 126)) + (export \"f64_select\" (func 127)) + (export \"br_if\" (func 128)) + (export \"br_table\" (func 129)) + (elem (;0;) (i32.const 0) 0 1 2 3 4 5 6 7)) + "; + 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 181 +fn c1_l181_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l181_action_invoke"); + let result = instance.call("i32_add", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 181 +fn c2_l181_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l181_action_invoke"); + let result = instance.call("i64_add", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 182 +fn c3_l182_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l182_action_invoke"); + let result = instance.call("i32_sub", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 182 +fn c4_l182_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l182_action_invoke"); + let result = instance.call("i64_sub", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 183 +fn c5_l183_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l183_action_invoke"); + let result = instance.call("i32_mul", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 183 +fn c6_l183_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l183_action_invoke"); + let result = instance.call("i64_mul", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 184 +fn c7_l184_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l184_action_invoke"); + let result = instance.call("i32_div_s", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 184 +fn c8_l184_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l184_action_invoke"); + let result = instance.call("i64_div_s", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 185 +fn c9_l185_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l185_action_invoke"); + let result = instance.call("i32_div_u", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 185 +fn c10_l185_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c10_l185_action_invoke"); + let result = instance.call("i64_div_u", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 186 +fn c11_l186_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c11_l186_action_invoke"); + let result = instance.call("i32_rem_s", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 186 +fn c12_l186_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c12_l186_action_invoke"); + let result = instance.call("i64_rem_s", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 187 +fn c13_l187_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c13_l187_action_invoke"); + let result = instance.call("i32_rem_u", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 187 +fn c14_l187_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c14_l187_action_invoke"); + let result = instance.call("i64_rem_u", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 188 +fn c15_l188_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c15_l188_action_invoke"); + let result = instance.call("i32_and", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 188 +fn c16_l188_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c16_l188_action_invoke"); + let result = instance.call("i64_and", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 189 +fn c17_l189_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c17_l189_action_invoke"); + let result = instance.call("i32_or", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 189 +fn c18_l189_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c18_l189_action_invoke"); + let result = instance.call("i64_or", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 190 +fn c19_l190_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c19_l190_action_invoke"); + let result = instance.call("i32_xor", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 190 +fn c20_l190_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c20_l190_action_invoke"); + let result = instance.call("i64_xor", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 191 +fn c21_l191_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c21_l191_action_invoke"); + let result = instance.call("i32_shl", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 191 +fn c22_l191_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c22_l191_action_invoke"); + let result = instance.call("i64_shl", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 192 +fn c23_l192_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c23_l192_action_invoke"); + let result = instance.call("i32_shr_u", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 192 +fn c24_l192_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c24_l192_action_invoke"); + let result = instance.call("i64_shr_u", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 193 +fn c25_l193_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c25_l193_action_invoke"); + let result = instance.call("i32_shr_s", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 193 +fn c26_l193_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c26_l193_action_invoke"); + let result = instance.call("i64_shr_s", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 194 +fn c27_l194_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c27_l194_action_invoke"); + let result = instance.call("i32_eq", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 194 +fn c28_l194_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c28_l194_action_invoke"); + let result = instance.call("i64_eq", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 195 +fn c29_l195_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c29_l195_action_invoke"); + let result = instance.call("i32_ne", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 195 +fn c30_l195_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c30_l195_action_invoke"); + let result = instance.call("i64_ne", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 196 +fn c31_l196_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c31_l196_action_invoke"); + let result = instance.call("i32_lt_s", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 196 +fn c32_l196_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c32_l196_action_invoke"); + let result = instance.call("i64_lt_s", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 197 +fn c33_l197_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c33_l197_action_invoke"); + let result = instance.call("i32_le_s", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 197 +fn c34_l197_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c34_l197_action_invoke"); + let result = instance.call("i64_le_s", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 198 +fn c35_l198_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c35_l198_action_invoke"); + let result = instance.call("i32_lt_u", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 198 +fn c36_l198_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c36_l198_action_invoke"); + let result = instance.call("i64_lt_u", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 199 +fn c37_l199_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c37_l199_action_invoke"); + let result = instance.call("i32_le_u", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 199 +fn c38_l199_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c38_l199_action_invoke"); + let result = instance.call("i64_le_u", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 200 +fn c39_l200_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c39_l200_action_invoke"); + let result = instance.call("i32_gt_s", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 200 +fn c40_l200_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c40_l200_action_invoke"); + let result = instance.call("i64_gt_s", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 201 +fn c41_l201_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c41_l201_action_invoke"); + let result = instance.call("i32_ge_s", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 201 +fn c42_l201_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c42_l201_action_invoke"); + let result = instance.call("i64_ge_s", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 202 +fn c43_l202_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c43_l202_action_invoke"); + let result = instance.call("i32_gt_u", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 202 +fn c44_l202_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c44_l202_action_invoke"); + let result = instance.call("i64_gt_u", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 203 +fn c45_l203_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c45_l203_action_invoke"); + let result = instance.call("i32_ge_u", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 203 +fn c46_l203_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c46_l203_action_invoke"); + let result = instance.call("i64_ge_u", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 204 +fn c47_l204_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c47_l204_action_invoke"); + let result = instance.call("i32_store", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 204 +fn c48_l204_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c48_l204_action_invoke"); + let result = instance.call("i64_store", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 205 +fn c49_l205_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c49_l205_action_invoke"); + let result = instance.call("i32_store8", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 205 +fn c50_l205_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c50_l205_action_invoke"); + let result = instance.call("i64_store8", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 206 +fn c51_l206_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c51_l206_action_invoke"); + let result = instance.call("i32_store16", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 206 +fn c52_l206_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c52_l206_action_invoke"); + let result = instance.call("i64_store16", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 207 +fn c53_l207_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c53_l207_action_invoke"); + let result = instance.call("i64_store32", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 208 +fn c54_l208_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c54_l208_action_invoke"); + let result = instance.call("i32_call", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 208 +fn c55_l208_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c55_l208_action_invoke"); + let result = instance.call("i64_call", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 209 +fn c56_l209_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c56_l209_action_invoke"); + let result = instance.call("i32_call_indirect", &[]); + assert_eq!(result, Ok(Some(Value::I32(66052 as i32)))); + result.map(|_| ()) +} + +// Line 210 +fn c57_l210_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c57_l210_action_invoke"); + let result = instance.call("i64_call_indirect", &[]); + assert_eq!(result, Ok(Some(Value::I32(66052 as i32)))); + result.map(|_| ()) +} + +// Line 211 +fn c58_l211_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c58_l211_action_invoke"); + let result = instance.call("i32_select", &[]); + assert_eq!(result, Ok(Some(Value::I32(66053 as i32)))); + result.map(|_| ()) +} + +// Line 211 +fn c59_l211_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c59_l211_action_invoke"); + let result = instance.call("i64_select", &[]); + assert_eq!(result, Ok(Some(Value::I32(66053 as i32)))); + result.map(|_| ()) +} + +// Line 213 +fn c60_l213_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c60_l213_action_invoke"); + let result = instance.call("f32_add", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 213 +fn c61_l213_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c61_l213_action_invoke"); + let result = instance.call("f64_add", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 214 +fn c62_l214_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c62_l214_action_invoke"); + let result = instance.call("f32_sub", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 214 +fn c63_l214_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c63_l214_action_invoke"); + let result = instance.call("f64_sub", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 215 +fn c64_l215_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c64_l215_action_invoke"); + let result = instance.call("f32_mul", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 215 +fn c65_l215_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c65_l215_action_invoke"); + let result = instance.call("f64_mul", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 216 +fn c66_l216_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c66_l216_action_invoke"); + let result = instance.call("f32_div", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 216 +fn c67_l216_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c67_l216_action_invoke"); + let result = instance.call("f64_div", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 217 +fn c68_l217_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c68_l217_action_invoke"); + let result = instance.call("f32_copysign", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 217 +fn c69_l217_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c69_l217_action_invoke"); + let result = instance.call("f64_copysign", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 218 +fn c70_l218_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c70_l218_action_invoke"); + let result = instance.call("f32_eq", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 218 +fn c71_l218_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c71_l218_action_invoke"); + let result = instance.call("f64_eq", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 219 +fn c72_l219_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c72_l219_action_invoke"); + let result = instance.call("f32_ne", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 219 +fn c73_l219_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c73_l219_action_invoke"); + let result = instance.call("f64_ne", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 220 +fn c74_l220_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c74_l220_action_invoke"); + let result = instance.call("f32_lt", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 220 +fn c75_l220_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c75_l220_action_invoke"); + let result = instance.call("f64_lt", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 221 +fn c76_l221_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c76_l221_action_invoke"); + let result = instance.call("f32_le", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 221 +fn c77_l221_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c77_l221_action_invoke"); + let result = instance.call("f64_le", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 222 +fn c78_l222_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c78_l222_action_invoke"); + let result = instance.call("f32_gt", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 222 +fn c79_l222_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c79_l222_action_invoke"); + let result = instance.call("f64_gt", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 223 +fn c80_l223_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c80_l223_action_invoke"); + let result = instance.call("f32_ge", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 223 +fn c81_l223_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c81_l223_action_invoke"); + let result = instance.call("f64_ge", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 224 +fn c82_l224_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c82_l224_action_invoke"); + let result = instance.call("f32_min", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 224 +fn c83_l224_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c83_l224_action_invoke"); + let result = instance.call("f64_min", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 225 +fn c84_l225_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c84_l225_action_invoke"); + let result = instance.call("f32_max", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 225 +fn c85_l225_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c85_l225_action_invoke"); + let result = instance.call("f64_max", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 226 +fn c86_l226_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c86_l226_action_invoke"); + let result = instance.call("f32_store", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 226 +fn c87_l226_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c87_l226_action_invoke"); + let result = instance.call("f64_store", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 227 +fn c88_l227_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c88_l227_action_invoke"); + let result = instance.call("f32_call", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 227 +fn c89_l227_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c89_l227_action_invoke"); + let result = instance.call("f64_call", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 228 +fn c90_l228_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c90_l228_action_invoke"); + let result = instance.call("f32_call_indirect", &[]); + assert_eq!(result, Ok(Some(Value::I32(66052 as i32)))); + result.map(|_| ()) +} + +// Line 229 +fn c91_l229_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c91_l229_action_invoke"); + let result = instance.call("f64_call_indirect", &[]); + assert_eq!(result, Ok(Some(Value::I32(66052 as i32)))); + result.map(|_| ()) +} + +// Line 230 +fn c92_l230_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c92_l230_action_invoke"); + let result = instance.call("f32_select", &[]); + assert_eq!(result, Ok(Some(Value::I32(66053 as i32)))); + result.map(|_| ()) +} + +// Line 230 +fn c93_l230_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c93_l230_action_invoke"); + let result = instance.call("f64_select", &[]); + assert_eq!(result, Ok(Some(Value::I32(66053 as i32)))); + result.map(|_| ()) +} + +// Line 232 +fn c94_l232_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c94_l232_action_invoke"); + let result = instance.call("br_if", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +// Line 233 +fn c95_l233_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c95_l233_action_invoke"); + let result = instance.call("br_table", &[]); + assert_eq!(result, Ok(Some(Value::I32(258 as i32)))); + result.map(|_| ()) +} + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l181_action_invoke(&mut instance); + c2_l181_action_invoke(&mut instance); + c3_l182_action_invoke(&mut instance); + c4_l182_action_invoke(&mut instance); + c5_l183_action_invoke(&mut instance); + c6_l183_action_invoke(&mut instance); + c7_l184_action_invoke(&mut instance); + c8_l184_action_invoke(&mut instance); + c9_l185_action_invoke(&mut instance); + c10_l185_action_invoke(&mut instance); + c11_l186_action_invoke(&mut instance); + c12_l186_action_invoke(&mut instance); + c13_l187_action_invoke(&mut instance); + c14_l187_action_invoke(&mut instance); + c15_l188_action_invoke(&mut instance); + c16_l188_action_invoke(&mut instance); + c17_l189_action_invoke(&mut instance); + c18_l189_action_invoke(&mut instance); + c19_l190_action_invoke(&mut instance); + c20_l190_action_invoke(&mut instance); + c21_l191_action_invoke(&mut instance); + c22_l191_action_invoke(&mut instance); + c23_l192_action_invoke(&mut instance); + c24_l192_action_invoke(&mut instance); + c25_l193_action_invoke(&mut instance); + c26_l193_action_invoke(&mut instance); + c27_l194_action_invoke(&mut instance); + c28_l194_action_invoke(&mut instance); + c29_l195_action_invoke(&mut instance); + c30_l195_action_invoke(&mut instance); + c31_l196_action_invoke(&mut instance); + c32_l196_action_invoke(&mut instance); + c33_l197_action_invoke(&mut instance); + c34_l197_action_invoke(&mut instance); + c35_l198_action_invoke(&mut instance); + c36_l198_action_invoke(&mut instance); + c37_l199_action_invoke(&mut instance); + c38_l199_action_invoke(&mut instance); + c39_l200_action_invoke(&mut instance); + c40_l200_action_invoke(&mut instance); + c41_l201_action_invoke(&mut instance); + c42_l201_action_invoke(&mut instance); + c43_l202_action_invoke(&mut instance); + c44_l202_action_invoke(&mut instance); + c45_l203_action_invoke(&mut instance); + c46_l203_action_invoke(&mut instance); + c47_l204_action_invoke(&mut instance); + c48_l204_action_invoke(&mut instance); + c49_l205_action_invoke(&mut instance); + c50_l205_action_invoke(&mut instance); + c51_l206_action_invoke(&mut instance); + c52_l206_action_invoke(&mut instance); + c53_l207_action_invoke(&mut instance); + c54_l208_action_invoke(&mut instance); + c55_l208_action_invoke(&mut instance); + c56_l209_action_invoke(&mut instance); + c57_l210_action_invoke(&mut instance); + c58_l211_action_invoke(&mut instance); + c59_l211_action_invoke(&mut instance); + c60_l213_action_invoke(&mut instance); + c61_l213_action_invoke(&mut instance); + c62_l214_action_invoke(&mut instance); + c63_l214_action_invoke(&mut instance); + c64_l215_action_invoke(&mut instance); + c65_l215_action_invoke(&mut instance); + c66_l216_action_invoke(&mut instance); + c67_l216_action_invoke(&mut instance); + c68_l217_action_invoke(&mut instance); + c69_l217_action_invoke(&mut instance); + c70_l218_action_invoke(&mut instance); + c71_l218_action_invoke(&mut instance); + c72_l219_action_invoke(&mut instance); + c73_l219_action_invoke(&mut instance); + c74_l220_action_invoke(&mut instance); + c75_l220_action_invoke(&mut instance); + c76_l221_action_invoke(&mut instance); + c77_l221_action_invoke(&mut instance); + c78_l222_action_invoke(&mut instance); + c79_l222_action_invoke(&mut instance); + c80_l223_action_invoke(&mut instance); + c81_l223_action_invoke(&mut instance); + c82_l224_action_invoke(&mut instance); + c83_l224_action_invoke(&mut instance); + c84_l225_action_invoke(&mut instance); + c85_l225_action_invoke(&mut instance); + c86_l226_action_invoke(&mut instance); + c87_l226_action_invoke(&mut instance); + c88_l227_action_invoke(&mut instance); + c89_l227_action_invoke(&mut instance); + c90_l228_action_invoke(&mut instance); + c91_l229_action_invoke(&mut instance); + c92_l230_action_invoke(&mut instance); + c93_l230_action_invoke(&mut instance); + c94_l232_action_invoke(&mut instance); + c95_l233_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/loop_.rs b/lib/runtime/tests/spectests/loop_.rs new file mode 100644 index 000000000..6cdaa4cd2 --- /dev/null +++ b/lib/runtime/tests/spectests/loop_.rs @@ -0,0 +1,1372 @@ +// 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/loop_.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 3 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func (param i32 i32) (result i32))) + (type (;1;) (func)) + (type (;2;) (func (result i32))) + (type (;3;) (func (param i32) (result i32))) + (type (;4;) (func (param i64) (result i64))) + (type (;5;) (func (param f32 f32) (result f32))) + (func (;0;) (type 1)) + (func (;1;) (type 1) + loop ;; label = @1 + end + loop ;; label = @1 + end) + (func (;2;) (type 2) (result i32) + loop ;; label = @1 + nop + end + loop (result i32) ;; label = @1 + i32.const 7 + end) + (func (;3;) (type 2) (result i32) + loop ;; label = @1 + call 0 + call 0 + call 0 + call 0 + end + loop (result i32) ;; label = @1 + call 0 + call 0 + call 0 + i32.const 8 + end) + (func (;4;) (type 2) (result i32) + loop (result i32) ;; label = @1 + loop ;; label = @2 + call 0 + block ;; label = @3 + end + nop + end + loop (result i32) ;; label = @2 + call 0 + i32.const 9 + end + end) + (func (;5;) (type 2) (result i32) + loop (result i32) ;; label = @1 + block (result i32) ;; label = @2 + loop (result i32) ;; label = @3 + block (result i32) ;; label = @4 + loop (result i32) ;; label = @5 + block (result i32) ;; label = @6 + loop (result i32) ;; label = @7 + block (result i32) ;; label = @8 + loop (result i32) ;; label = @9 + block (result i32) ;; label = @10 + loop (result i32) ;; label = @11 + block (result i32) ;; label = @12 + loop (result i32) ;; label = @13 + block (result i32) ;; label = @14 + loop (result i32) ;; label = @15 + block (result i32) ;; label = @16 + loop (result i32) ;; label = @17 + block (result i32) ;; label = @18 + loop (result i32) ;; label = @19 + block (result i32) ;; label = @20 + loop (result i32) ;; label = @21 + block (result i32) ;; label = @22 + loop (result i32) ;; label = @23 + block (result i32) ;; label = @24 + loop (result i32) ;; label = @25 + block (result i32) ;; label = @26 + loop (result i32) ;; label = @27 + block (result i32) ;; label = @28 + loop (result i32) ;; label = @29 + block (result i32) ;; label = @30 + loop (result i32) ;; label = @31 + block (result i32) ;; label = @32 + loop (result i32) ;; label = @33 + block (result i32) ;; label = @34 + loop (result i32) ;; label = @35 + block (result i32) ;; label = @36 + loop (result i32) ;; label = @37 + block (result i32) ;; label = @38 + loop (result i32) ;; label = @39 + block (result i32) ;; label = @40 + call 0 + i32.const 150 + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end + end) + (func (;6;) (type 2) (result i32) + loop (result i32) ;; label = @1 + i32.const 1 + end + i32.const 2 + i32.const 3 + select) + (func (;7;) (type 2) (result i32) + i32.const 2 + loop (result i32) ;; label = @1 + i32.const 1 + end + i32.const 3 + select) + (func (;8;) (type 2) (result i32) + i32.const 2 + i32.const 3 + loop (result i32) ;; label = @1 + i32.const 1 + end + select) + (func (;9;) (type 1) + loop (result i32) ;; label = @1 + i32.const 1 + end + if ;; label = @1 + call 0 + end) + (func (;10;) (type 2) (result i32) + i32.const 1 + if (result i32) ;; label = @1 + loop (result i32) ;; label = @2 + i32.const 1 + end + else + i32.const 2 + end) + (func (;11;) (type 2) (result i32) + i32.const 1 + if (result i32) ;; label = @1 + i32.const 2 + else + loop (result i32) ;; label = @2 + i32.const 1 + end + end) + (func (;12;) (type 2) (result i32) + block (result i32) ;; label = @1 + loop (result i32) ;; label = @2 + i32.const 1 + end + i32.const 2 + br_if 0 (;@1;) + end) + (func (;13;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 2 + loop (result i32) ;; label = @2 + i32.const 1 + end + br_if 0 (;@1;) + end) + (func (;14;) (type 2) (result i32) + block (result i32) ;; label = @1 + loop (result i32) ;; label = @2 + i32.const 1 + end + i32.const 2 + br_table 0 (;@1;) 0 (;@1;) + end) + (func (;15;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 2 + loop (result i32) ;; label = @2 + i32.const 1 + end + br_table 0 (;@1;) 0 (;@1;) + end) + (func (;16;) (type 0) (param i32 i32) (result i32) + get_local 0) + (func (;17;) (type 2) (result i32) + block (result i32) ;; label = @1 + loop (result i32) ;; label = @2 + i32.const 1 + end + i32.const 2 + i32.const 0 + call_indirect (type 0) + end) + (func (;18;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 2 + loop (result i32) ;; label = @2 + i32.const 1 + end + i32.const 0 + call_indirect (type 0) + end) + (func (;19;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + i32.const 2 + loop (result i32) ;; label = @2 + i32.const 0 + end + call_indirect (type 0) + end) + (func (;20;) (type 1) + loop (result i32) ;; label = @1 + i32.const 1 + end + i32.const 1 + i32.store) + (func (;21;) (type 1) + i32.const 10 + loop (result i32) ;; label = @1 + i32.const 1 + end + i32.store) + (func (;22;) (type 2) (result i32) + loop (result i32) ;; label = @1 + i32.const 1 + end + memory.grow) + (func (;23;) (type 3) (param i32) (result i32) + get_local 0) + (func (;24;) (type 2) (result i32) + loop (result i32) ;; label = @1 + i32.const 1 + end + call 23) + (func (;25;) (type 2) (result i32) + loop (result i32) ;; label = @1 + i32.const 1 + end + return) + (func (;26;) (type 1) + loop (result i32) ;; label = @1 + i32.const 1 + end + drop) + (func (;27;) (type 2) (result i32) + block (result i32) ;; label = @1 + loop (result i32) ;; label = @2 + i32.const 1 + end + br 0 (;@1;) + end) + (func (;28;) (type 2) (result i32) + (local i32) + loop (result i32) ;; label = @1 + i32.const 1 + end + set_local 0 + get_local 0) + (func (;29;) (type 2) (result i32) + (local i32) + loop (result i32) ;; label = @1 + i32.const 1 + end + tee_local 0) + (func (;30;) (type 2) (result i32) + loop (result i32) ;; label = @1 + i32.const 1 + end + set_global 0 + get_global 0) + (func (;31;) (type 2) (result i32) + loop (result i32) ;; label = @1 + i32.const 1 + end + i32.load) + (func (;32;) (type 2) (result i32) + loop (result i32) ;; label = @1 + call 0 + i32.const 13 + end + i32.ctz) + (func (;33;) (type 2) (result i32) + loop (result i32) ;; label = @1 + call 0 + i32.const 3 + end + loop (result i32) ;; label = @1 + call 0 + i32.const 4 + end + i32.mul) + (func (;34;) (type 2) (result i32) + loop (result i32) ;; label = @1 + call 0 + i32.const 13 + end + i32.eqz) + (func (;35;) (type 2) (result i32) + loop (result f32) ;; label = @1 + call 0 + f32.const 0x1.8p+1 (;=3;) + end + loop (result f32) ;; label = @1 + call 0 + f32.const 0x1.8p+1 (;=3;) + end + f32.gt) + (func (;36;) (type 2) (result i32) + block ;; label = @1 + loop ;; label = @2 + br 1 (;@1;) + br 0 (;@2;) + unreachable + end + end + block ;; label = @1 + loop ;; label = @2 + i32.const 1 + br_if 1 (;@1;) + unreachable + end + end + block ;; label = @1 + loop ;; label = @2 + i32.const 0 + br_table 1 (;@1;) + unreachable + end + end + block ;; label = @1 + loop ;; label = @2 + i32.const 1 + br_table 1 (;@1;) 1 (;@1;) 1 (;@1;) + unreachable + end + end + i32.const 19) + (func (;37;) (type 2) (result i32) + block (result i32) ;; label = @1 + loop (result i32) ;; label = @2 + i32.const 18 + br 1 (;@1;) + br 0 (;@2;) + i32.const 19 + end + end) + (func (;38;) (type 2) (result i32) + block (result i32) ;; label = @1 + loop (result i32) ;; label = @2 + i32.const 18 + br 1 (;@1;) + i32.const 19 + br 1 (;@1;) + i32.const 20 + i32.const 0 + br_if 1 (;@1;) + drop + i32.const 20 + i32.const 1 + br_if 1 (;@1;) + drop + i32.const 21 + br 1 (;@1;) + i32.const 22 + i32.const 0 + br_table 1 (;@1;) + i32.const 23 + i32.const 1 + br_table 1 (;@1;) 1 (;@1;) 1 (;@1;) + i32.const 21 + end + end) + (func (;39;) (type 2) (result i32) + (local i32) + i32.const 0 + set_local 0 + get_local 0 + block (result i32) ;; label = @1 + loop (result i32) ;; label = @2 + block (result i32) ;; label = @3 + i32.const 1 + br 2 (;@1;) + end + end + end + i32.add + set_local 0 + get_local 0 + block (result i32) ;; label = @1 + loop (result i32) ;; label = @2 + loop (result i32) ;; label = @3 + i32.const 2 + br 2 (;@1;) + end + end + end + i32.add + set_local 0 + get_local 0 + block (result i32) ;; label = @1 + loop (result i32) ;; label = @2 + block (result i32) ;; label = @3 + loop (result i32) ;; label = @4 + i32.const 4 + br 1 (;@3;) + end + end + end + end + i32.add + set_local 0 + get_local 0 + block (result i32) ;; label = @1 + loop (result i32) ;; label = @2 + i32.const 8 + br 1 (;@1;) + i32.ctz + end + end + i32.add + set_local 0 + get_local 0 + block (result i32) ;; label = @1 + loop (result i32) ;; label = @2 + loop (result i32) ;; label = @3 + i32.const 16 + br 2 (;@1;) + end + i32.ctz + end + end + i32.add + set_local 0 + get_local 0) + (func (;40;) (type 2) (result i32) + (local i32) + i32.const 0 + set_local 0 + get_local 0 + loop (result i32) ;; label = @1 + loop (result i32) ;; label = @2 + br 1 (;@1;) + end + end + i32.add + set_local 0 + get_local 0 + loop (result i32) ;; label = @1 + br 0 (;@1;) + i32.ctz + end + i32.add + set_local 0 + get_local 0 + loop (result i32) ;; label = @1 + loop (result i32) ;; label = @2 + br 1 (;@1;) + end + i32.ctz + end + i32.add + set_local 0 + get_local 0) + (func (;41;) (type 2) (result i32) + (local i32) + block ;; label = @1 + loop ;; label = @2 + i32.const 1 + set_local 0 + get_local 0 + i32.const 3 + i32.mul + set_local 0 + get_local 0 + i32.const 5 + i32.sub + set_local 0 + get_local 0 + i32.const 7 + i32.mul + set_local 0 + br 1 (;@1;) + get_local 0 + i32.const 100 + i32.mul + set_local 0 + end + end + get_local 0 + i32.const -14 + i32.eq) + (func (;42;) (type 4) (param i64) (result i64) + (local i64) + i64.const 1 + set_local 1 + block ;; label = @1 + loop ;; label = @2 + get_local 0 + i64.eqz + br_if 1 (;@1;) + get_local 0 + get_local 1 + i64.mul + set_local 1 + get_local 0 + i64.const 1 + i64.sub + set_local 0 + br 0 (;@2;) + end + end + get_local 1) + (func (;43;) (type 4) (param i64) (result i64) + (local i64 i64) + i64.const 1 + set_local 1 + i64.const 2 + set_local 2 + block ;; label = @1 + loop ;; label = @2 + get_local 2 + get_local 0 + i64.gt_u + br_if 1 (;@1;) + get_local 1 + get_local 2 + i64.mul + set_local 1 + get_local 2 + i64.const 1 + i64.add + set_local 2 + br 0 (;@2;) + end + end + get_local 1) + (func (;44;) (type 5) (param f32 f32) (result f32) + (local f32 f32) + block ;; label = @1 + loop ;; label = @2 + get_local 0 + f32.const 0x0p+0 (;=0;) + f32.eq + br_if 1 (;@1;) + get_local 1 + set_local 2 + block ;; label = @3 + loop ;; label = @4 + get_local 2 + f32.const 0x0p+0 (;=0;) + f32.eq + br_if 1 (;@3;) + get_local 2 + f32.const 0x0p+0 (;=0;) + f32.lt + br_if 3 (;@1;) + get_local 3 + get_local 2 + f32.add + set_local 3 + get_local 2 + f32.const 0x1p+1 (;=2;) + f32.sub + set_local 2 + br 0 (;@4;) + end + end + get_local 3 + get_local 0 + f32.div + set_local 3 + get_local 0 + f32.const 0x1p+0 (;=1;) + f32.sub + set_local 0 + br 0 (;@2;) + end + end + get_local 3) + (table (;0;) 1 1 anyfunc) + (memory (;0;) 1) + (global (;0;) (mut i32) (i32.const 0)) + (export \"empty\" (func 1)) + (export \"singular\" (func 2)) + (export \"multi\" (func 3)) + (export \"nested\" (func 4)) + (export \"deep\" (func 5)) + (export \"as-select-first\" (func 6)) + (export \"as-select-mid\" (func 7)) + (export \"as-select-last\" (func 8)) + (export \"as-if-condition\" (func 9)) + (export \"as-if-then\" (func 10)) + (export \"as-if-else\" (func 11)) + (export \"as-br_if-first\" (func 12)) + (export \"as-br_if-last\" (func 13)) + (export \"as-br_table-first\" (func 14)) + (export \"as-br_table-last\" (func 15)) + (export \"as-call_indirect-first\" (func 17)) + (export \"as-call_indirect-mid\" (func 18)) + (export \"as-call_indirect-last\" (func 19)) + (export \"as-store-first\" (func 20)) + (export \"as-store-last\" (func 21)) + (export \"as-memory.grow-value\" (func 22)) + (export \"as-call-value\" (func 24)) + (export \"as-return-value\" (func 25)) + (export \"as-drop-operand\" (func 26)) + (export \"as-br-value\" (func 27)) + (export \"as-set_local-value\" (func 28)) + (export \"as-tee_local-value\" (func 29)) + (export \"as-set_global-value\" (func 30)) + (export \"as-load-operand\" (func 31)) + (export \"as-unary-operand\" (func 32)) + (export \"as-binary-operand\" (func 33)) + (export \"as-test-operand\" (func 34)) + (export \"as-compare-operand\" (func 35)) + (export \"break-bare\" (func 36)) + (export \"break-value\" (func 37)) + (export \"break-repeated\" (func 38)) + (export \"break-inner\" (func 39)) + (export \"cont-inner\" (func 40)) + (export \"effects\" (func 41)) + (export \"while\" (func 42)) + (export \"for\" (func 43)) + (export \"nesting\" (func 44)) + (elem (;0;) (i32.const 0) 16)) + "; + 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 305 +fn c1_l305_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l305_action_invoke"); + let result = instance.call("empty", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 306 +fn c2_l306_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l306_action_invoke"); + let result = instance.call("singular", &[]); + assert_eq!(result, Ok(Some(Value::I32(7 as i32)))); + result.map(|_| ()) +} + +// Line 307 +fn c3_l307_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l307_action_invoke"); + let result = instance.call("multi", &[]); + assert_eq!(result, Ok(Some(Value::I32(8 as i32)))); + result.map(|_| ()) +} + +// Line 308 +fn c4_l308_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l308_action_invoke"); + let result = instance.call("nested", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 309 +fn c5_l309_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l309_action_invoke"); + let result = instance.call("deep", &[]); + assert_eq!(result, Ok(Some(Value::I32(150 as i32)))); + result.map(|_| ()) +} + +// Line 311 +fn c6_l311_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l311_action_invoke"); + let result = instance.call("as-select-first", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 312 +fn c7_l312_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l312_action_invoke"); + let result = instance.call("as-select-mid", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 313 +fn c8_l313_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l313_action_invoke"); + let result = instance.call("as-select-last", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 315 +fn c9_l315_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l315_action_invoke"); + let result = instance.call("as-if-condition", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 316 +fn c10_l316_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c10_l316_action_invoke"); + let result = instance.call("as-if-then", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 317 +fn c11_l317_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c11_l317_action_invoke"); + let result = instance.call("as-if-else", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 319 +fn c12_l319_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c12_l319_action_invoke"); + let result = instance.call("as-br_if-first", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 320 +fn c13_l320_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c13_l320_action_invoke"); + let result = instance.call("as-br_if-last", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 322 +fn c14_l322_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c14_l322_action_invoke"); + let result = instance.call("as-br_table-first", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 323 +fn c15_l323_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c15_l323_action_invoke"); + let result = instance.call("as-br_table-last", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 325 +fn c16_l325_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c16_l325_action_invoke"); + let result = instance.call("as-call_indirect-first", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 326 +fn c17_l326_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c17_l326_action_invoke"); + let result = instance.call("as-call_indirect-mid", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 327 +fn c18_l327_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c18_l327_action_invoke"); + let result = instance.call("as-call_indirect-last", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 329 +fn c19_l329_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c19_l329_action_invoke"); + let result = instance.call("as-store-first", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 330 +fn c20_l330_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c20_l330_action_invoke"); + let result = instance.call("as-store-last", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 332 +fn c21_l332_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c21_l332_action_invoke"); + let result = instance.call("as-memory.grow-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 333 +fn c22_l333_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c22_l333_action_invoke"); + let result = instance.call("as-call-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 334 +fn c23_l334_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c23_l334_action_invoke"); + let result = instance.call("as-return-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 335 +fn c24_l335_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c24_l335_action_invoke"); + let result = instance.call("as-drop-operand", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 336 +fn c25_l336_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c25_l336_action_invoke"); + let result = instance.call("as-br-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 337 +fn c26_l337_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c26_l337_action_invoke"); + let result = instance.call("as-set_local-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 338 +fn c27_l338_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c27_l338_action_invoke"); + let result = instance.call("as-tee_local-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 339 +fn c28_l339_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c28_l339_action_invoke"); + let result = instance.call("as-set_global-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 340 +fn c29_l340_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c29_l340_action_invoke"); + let result = instance.call("as-load-operand", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 342 +fn c30_l342_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c30_l342_action_invoke"); + let result = instance.call("as-unary-operand", &[]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 343 +fn c31_l343_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c31_l343_action_invoke"); + let result = instance.call("as-binary-operand", &[]); + assert_eq!(result, Ok(Some(Value::I32(12 as i32)))); + result.map(|_| ()) +} + +// Line 344 +fn c32_l344_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c32_l344_action_invoke"); + let result = instance.call("as-test-operand", &[]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 345 +fn c33_l345_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c33_l345_action_invoke"); + let result = instance.call("as-compare-operand", &[]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 347 +fn c34_l347_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c34_l347_action_invoke"); + let result = instance.call("break-bare", &[]); + assert_eq!(result, Ok(Some(Value::I32(19 as i32)))); + result.map(|_| ()) +} + +// Line 348 +fn c35_l348_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c35_l348_action_invoke"); + let result = instance.call("break-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(18 as i32)))); + result.map(|_| ()) +} + +// Line 349 +fn c36_l349_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c36_l349_action_invoke"); + let result = instance.call("break-repeated", &[]); + assert_eq!(result, Ok(Some(Value::I32(18 as i32)))); + result.map(|_| ()) +} + +// Line 350 +fn c37_l350_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c37_l350_action_invoke"); + let result = instance.call("break-inner", &[]); + assert_eq!(result, Ok(Some(Value::I32(31 as i32)))); + result.map(|_| ()) +} + +// Line 352 +fn c38_l352_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c38_l352_action_invoke"); + let result = instance.call("effects", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 354 +fn c39_l354_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c39_l354_action_invoke"); + let result = instance.call("while", &[Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 355 +fn c40_l355_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c40_l355_action_invoke"); + let result = instance.call("while", &[Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 356 +fn c41_l356_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c41_l356_action_invoke"); + let result = instance.call("while", &[Value::I64(2 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(2 as i64)))); + result.map(|_| ()) +} + +// Line 357 +fn c42_l357_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c42_l357_action_invoke"); + let result = instance.call("while", &[Value::I64(3 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(6 as i64)))); + result.map(|_| ()) +} + +// Line 358 +fn c43_l358_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c43_l358_action_invoke"); + let result = instance.call("while", &[Value::I64(5 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(120 as i64)))); + result.map(|_| ()) +} + +// Line 359 +fn c44_l359_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c44_l359_action_invoke"); + let result = instance.call("while", &[Value::I64(20 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(2432902008176640000 as i64)))); + result.map(|_| ()) +} + +// Line 361 +fn c45_l361_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c45_l361_action_invoke"); + let result = instance.call("for", &[Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 362 +fn c46_l362_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c46_l362_action_invoke"); + let result = instance.call("for", &[Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(1 as i64)))); + result.map(|_| ()) +} + +// Line 363 +fn c47_l363_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c47_l363_action_invoke"); + let result = instance.call("for", &[Value::I64(2 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(2 as i64)))); + result.map(|_| ()) +} + +// Line 364 +fn c48_l364_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c48_l364_action_invoke"); + let result = instance.call("for", &[Value::I64(3 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(6 as i64)))); + result.map(|_| ()) +} + +// Line 365 +fn c49_l365_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c49_l365_action_invoke"); + let result = instance.call("for", &[Value::I64(5 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(120 as i64)))); + result.map(|_| ()) +} + +// Line 366 +fn c50_l366_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c50_l366_action_invoke"); + let result = instance.call("for", &[Value::I64(20 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(2432902008176640000 as i64)))); + result.map(|_| ()) +} + +// Line 368 +fn c51_l368_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c51_l368_action_invoke"); + let result = instance.call("nesting", &[Value::F32((0.0f32).to_bits()), Value::F32((7.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 369 +fn c52_l369_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c52_l369_action_invoke"); + let result = instance.call("nesting", &[Value::F32((7.0f32).to_bits()), Value::F32((0.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 370 +fn c53_l370_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c53_l370_action_invoke"); + let result = instance.call("nesting", &[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 371 +fn c54_l371_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c54_l371_action_invoke"); + let result = instance.call("nesting", &[Value::F32((1.0f32).to_bits()), Value::F32((2.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((2.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 372 +fn c55_l372_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c55_l372_action_invoke"); + let result = instance.call("nesting", &[Value::F32((1.0f32).to_bits()), Value::F32((3.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((4.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 373 +fn c56_l373_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c56_l373_action_invoke"); + let result = instance.call("nesting", &[Value::F32((1.0f32).to_bits()), Value::F32((4.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((6.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 374 +fn c57_l374_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c57_l374_action_invoke"); + let result = instance.call("nesting", &[Value::F32((1.0f32).to_bits()), Value::F32((100.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((2550.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 375 +fn c58_l375_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c58_l375_action_invoke"); + let result = instance.call("nesting", &[Value::F32((1.0f32).to_bits()), Value::F32((101.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((2601.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 376 +fn c59_l376_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c59_l376_action_invoke"); + let result = instance.call("nesting", &[Value::F32((2.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 377 +fn c60_l377_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c60_l377_action_invoke"); + let result = instance.call("nesting", &[Value::F32((3.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 378 +fn c61_l378_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c61_l378_action_invoke"); + let result = instance.call("nesting", &[Value::F32((10.0f32).to_bits()), Value::F32((1.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 379 +fn c62_l379_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c62_l379_action_invoke"); + let result = instance.call("nesting", &[Value::F32((2.0f32).to_bits()), Value::F32((2.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((3.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 380 +fn c63_l380_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c63_l380_action_invoke"); + let result = instance.call("nesting", &[Value::F32((2.0f32).to_bits()), Value::F32((3.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((4.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 381 +fn c64_l381_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c64_l381_action_invoke"); + let result = instance.call("nesting", &[Value::F32((7.0f32).to_bits()), Value::F32((4.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((10.309524f32).to_bits())))); + result.map(|_| ()) +} + +// Line 382 +fn c65_l382_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c65_l382_action_invoke"); + let result = instance.call("nesting", &[Value::F32((7.0f32).to_bits()), Value::F32((100.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((4381.548f32).to_bits())))); + result.map(|_| ()) +} + +// Line 383 +fn c66_l383_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c66_l383_action_invoke"); + let result = instance.call("nesting", &[Value::F32((7.0f32).to_bits()), Value::F32((101.0f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((2601.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 386 +#[test] +fn c67_l386_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 7, 1, 5, 0, 3, 64, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 390 +#[test] +fn c68_l390_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 7, 1, 5, 0, 3, 64, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 394 +#[test] +fn c69_l394_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 7, 1, 5, 0, 3, 64, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 398 +#[test] +fn c70_l398_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 7, 1, 5, 0, 3, 64, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 403 +#[test] +fn c71_l403_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 0, 3, 64, 65, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 409 +#[test] +fn c72_l409_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 7, 1, 5, 0, 3, 127, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 415 +#[test] +fn c73_l415_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 8, 1, 6, 0, 3, 127, 1, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 421 +#[test] +fn c74_l421_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 12, 1, 10, 0, 3, 127, 67, 0, 0, 0, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 427 +#[test] +fn c75_l427_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 11, 1, 9, 0, 3, 126, 0, 0, 0, 27, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 435 +#[test] +fn c76_l435_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 108, 111, 111, 112, 32, 101, 110, 100, 32, 36, 108, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 439 +#[test] +fn c77_l439_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 108, 111, 111, 112, 32, 36, 97, 32, 101, 110, 100, 32, 36, 108, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l305_action_invoke(&mut instance); + c2_l306_action_invoke(&mut instance); + c3_l307_action_invoke(&mut instance); + c4_l308_action_invoke(&mut instance); + c5_l309_action_invoke(&mut instance); + c6_l311_action_invoke(&mut instance); + c7_l312_action_invoke(&mut instance); + c8_l313_action_invoke(&mut instance); + c9_l315_action_invoke(&mut instance); + c10_l316_action_invoke(&mut instance); + c11_l317_action_invoke(&mut instance); + c12_l319_action_invoke(&mut instance); + c13_l320_action_invoke(&mut instance); + c14_l322_action_invoke(&mut instance); + c15_l323_action_invoke(&mut instance); + c16_l325_action_invoke(&mut instance); + c17_l326_action_invoke(&mut instance); + c18_l327_action_invoke(&mut instance); + c19_l329_action_invoke(&mut instance); + c20_l330_action_invoke(&mut instance); + c21_l332_action_invoke(&mut instance); + c22_l333_action_invoke(&mut instance); + c23_l334_action_invoke(&mut instance); + c24_l335_action_invoke(&mut instance); + c25_l336_action_invoke(&mut instance); + c26_l337_action_invoke(&mut instance); + c27_l338_action_invoke(&mut instance); + c28_l339_action_invoke(&mut instance); + c29_l340_action_invoke(&mut instance); + c30_l342_action_invoke(&mut instance); + c31_l343_action_invoke(&mut instance); + c32_l344_action_invoke(&mut instance); + c33_l345_action_invoke(&mut instance); + c34_l347_action_invoke(&mut instance); + c35_l348_action_invoke(&mut instance); + c36_l349_action_invoke(&mut instance); + c37_l350_action_invoke(&mut instance); + c38_l352_action_invoke(&mut instance); + c39_l354_action_invoke(&mut instance); + c40_l355_action_invoke(&mut instance); + c41_l356_action_invoke(&mut instance); + c42_l357_action_invoke(&mut instance); + c43_l358_action_invoke(&mut instance); + c44_l359_action_invoke(&mut instance); + c45_l361_action_invoke(&mut instance); + c46_l362_action_invoke(&mut instance); + c47_l363_action_invoke(&mut instance); + c48_l364_action_invoke(&mut instance); + c49_l365_action_invoke(&mut instance); + c50_l366_action_invoke(&mut instance); + c51_l368_action_invoke(&mut instance); + c52_l369_action_invoke(&mut instance); + c53_l370_action_invoke(&mut instance); + c54_l371_action_invoke(&mut instance); + c55_l372_action_invoke(&mut instance); + c56_l373_action_invoke(&mut instance); + c57_l374_action_invoke(&mut instance); + c58_l375_action_invoke(&mut instance); + c59_l376_action_invoke(&mut instance); + c60_l377_action_invoke(&mut instance); + c61_l378_action_invoke(&mut instance); + c62_l379_action_invoke(&mut instance); + c63_l380_action_invoke(&mut instance); + c64_l381_action_invoke(&mut instance); + c65_l382_action_invoke(&mut instance); + c66_l383_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/memory.rs b/lib/runtime/tests/spectests/memory.rs new file mode 100644 index 000000000..8cd1e37bf --- /dev/null +++ b/lib/runtime/tests/spectests/memory.rs @@ -0,0 +1,359 @@ +// 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/memory.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 2 +fn create_module_1() -> Box { + let module_str = "(module + (memory (;0;) 0 0)) + "; + 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 3 + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); +} +fn create_module_2() -> Box { + let module_str = "(module + (memory (;0;) 0 1)) + "; + 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_2(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 4 + +#[test] +fn test_module_2() { + let mut instance = create_module_2(); + // We group the calls together + start_module_2(&mut instance); +} +fn create_module_3() -> Box { + let module_str = "(module + (memory (;0;) 1 256)) + "; + 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_3(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 5 + +#[test] +fn test_module_3() { + let mut instance = create_module_3(); + // We group the calls together + start_module_3(&mut instance); +} +fn create_module_4() -> Box { + let module_str = "(module + (memory (;0;) 0 65536)) + "; + 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_4(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 7 +#[test] +fn c4_l7_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 5, 2, 0, 0, 0, 0]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 8 +#[test] +fn c5_l8_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 2, 20, 1, 8, 115, 112, 101, 99, 116, 101, 115, 116, 6, 109, 101, 109, 111, 114, 121, 2, 0, 0, 5, 3, 1, 0, 0]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 10 + +#[test] +fn test_module_4() { + let mut instance = create_module_4(); + // We group the calls together + start_module_4(&mut instance); +} +fn create_module_5() -> Box { + let module_str = "(module + (type (;0;) (func (result i32))) + (func (;0;) (type 0) (result i32) + memory.size) + (memory (;0;) 0 0) + (export \"memsize\" (func 0)) + (data (;0;) (i32.const 0) \"\")) + "; + 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_5(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 11 +fn c7_l11_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l11_action_invoke"); + let result = instance.call("memsize", &[]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 12 + +#[test] +fn test_module_5() { + let mut instance = create_module_5(); + // We group the calls together + start_module_5(&mut instance); + c7_l11_action_invoke(&mut instance); +} +fn create_module_6() -> Box { + let module_str = "(module + (type (;0;) (func (result i32))) + (func (;0;) (type 0) (result i32) + memory.size) + (memory (;0;) 0 0) + (export \"memsize\" (func 0)) + (data (;0;) (i32.const 0) \"\")) + "; + 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_6(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 13 +fn c9_l13_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l13_action_invoke"); + let result = instance.call("memsize", &[]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 14 + +#[test] +fn test_module_6() { + let mut instance = create_module_6(); + // We group the calls together + start_module_6(&mut instance); + c9_l13_action_invoke(&mut instance); +} +fn create_module_7() -> Box { + let module_str = "(module + (type (;0;) (func (result i32))) + (func (;0;) (type 0) (result i32) + memory.size) + (memory (;0;) 1 1) + (export \"memsize\" (func 0)) + (data (;0;) (i32.const 0) \"x\")) + "; + 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_7(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 15 +fn c11_l15_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c11_l15_action_invoke"); + let result = instance.call("memsize", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 17 +#[test] +fn c12_l17_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 11, 6, 1, 0, 65, 0, 11, 0]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 18 +#[test] +fn c13_l18_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 11, 6, 1, 0, 65, 0, 11, 0]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 19 +#[test] +fn c14_l19_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 11, 7, 1, 0, 65, 0, 11, 1, 120]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 22 +#[test] +fn c15_l22_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 10, 1, 8, 0, 65, 0, 42, 2, 0, 26, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 26 +#[test] +fn c16_l26_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 14, 1, 12, 0, 67, 0, 0, 0, 0, 65, 0, 56, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 30 +#[test] +fn c17_l30_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 10, 1, 8, 0, 65, 0, 44, 0, 0, 26, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 34 +#[test] +fn c18_l34_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 11, 1, 9, 0, 65, 0, 65, 0, 58, 0, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 38 +#[test] +fn c19_l38_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 63, 0, 26, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 42 +#[test] +fn c20_l42_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 0, 64, 0, 26, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 48 +#[test] +fn c21_l48_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 4, 1, 1, 1, 0]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 52 +#[test] +fn c22_l52_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 5, 1, 0, 129, 128, 4]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 56 +#[test] +fn c23_l56_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 7, 1, 0, 128, 128, 128, 128, 8]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 60 +#[test] +fn c24_l60_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 7, 1, 0, 255, 255, 255, 255, 15]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 64 +#[test] +fn c25_l64_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 6, 1, 1, 0, 129, 128, 4]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 68 +#[test] +fn c26_l68_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 8, 1, 1, 0, 128, 128, 128, 128, 8]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 72 +#[test] +fn c27_l72_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 8, 1, 1, 0, 255, 255, 255, 255, 15]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +#[test] +fn test_module_7() { + let mut instance = create_module_7(); + // We group the calls together + start_module_7(&mut instance); + c11_l15_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/memory_grow.rs b/lib/runtime/tests/spectests/memory_grow.rs new file mode 100644 index 000000000..86fcefd56 --- /dev/null +++ b/lib/runtime/tests/spectests/memory_grow.rs @@ -0,0 +1,1265 @@ +// 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/memory_grow.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 1 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func (result i32))) + (type (;1;) (func)) + (type (;2;) (func (param i32) (result i32))) + (func (;0;) (type 0) (result i32) + i32.const 0 + i32.load) + (func (;1;) (type 1) + i32.const 0 + i32.const 2 + i32.store) + (func (;2;) (type 0) (result i32) + i32.const 65536 + i32.load) + (func (;3;) (type 1) + i32.const 65536 + i32.const 3 + i32.store) + (func (;4;) (type 2) (param i32) (result i32) + get_local 0 + memory.grow) + (func (;5;) (type 0) (result i32) + memory.size) + (memory (;0;) 0) + (export \"load_at_zero\" (func 0)) + (export \"store_at_zero\" (func 1)) + (export \"load_at_page_size\" (func 2)) + (export \"store_at_page_size\" (func 3)) + (export \"grow\" (func 4)) + (export \"size\" (func 5))) + "; + 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 14 +fn c1_l14_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l14_action_invoke"); + let result = instance.call("size", &[]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 15 +fn c2_l15_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l15_action_invoke"); + let result = instance.call("store_at_zero", &[]); + + result.map(|_| ()) +} + +#[test] +fn c2_l15_assert_trap() { + let mut instance = create_module_1(); + let result = c2_l15_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 16 +fn c3_l16_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l16_action_invoke"); + let result = instance.call("load_at_zero", &[]); + + result.map(|_| ()) +} + +#[test] +fn c3_l16_assert_trap() { + let mut instance = create_module_1(); + let result = c3_l16_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 17 +fn c4_l17_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l17_action_invoke"); + let result = instance.call("store_at_page_size", &[]); + + result.map(|_| ()) +} + +#[test] +fn c4_l17_assert_trap() { + let mut instance = create_module_1(); + let result = c4_l17_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 18 +fn c5_l18_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l18_action_invoke"); + let result = instance.call("load_at_page_size", &[]); + + result.map(|_| ()) +} + +#[test] +fn c5_l18_assert_trap() { + let mut instance = create_module_1(); + let result = c5_l18_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 19 +fn c6_l19_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l19_action_invoke"); + let result = instance.call("grow", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 20 +fn c7_l20_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l20_action_invoke"); + let result = instance.call("size", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 21 +fn c8_l21_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l21_action_invoke"); + let result = instance.call("load_at_zero", &[]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 22 +fn c9_l22_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l22_action_invoke"); + let result = instance.call("store_at_zero", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 23 +fn c10_l23_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c10_l23_action_invoke"); + let result = instance.call("load_at_zero", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 24 +fn c11_l24_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c11_l24_action_invoke"); + let result = instance.call("store_at_page_size", &[]); + + result.map(|_| ()) +} + +#[test] +fn c11_l24_assert_trap() { + let mut instance = create_module_1(); + let result = c11_l24_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 25 +fn c12_l25_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c12_l25_action_invoke"); + let result = instance.call("load_at_page_size", &[]); + + result.map(|_| ()) +} + +#[test] +fn c12_l25_assert_trap() { + let mut instance = create_module_1(); + let result = c12_l25_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 26 +fn c13_l26_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c13_l26_action_invoke"); + let result = instance.call("grow", &[Value::I32(4 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 27 +fn c14_l27_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c14_l27_action_invoke"); + let result = instance.call("size", &[]); + assert_eq!(result, Ok(Some(Value::I32(5 as i32)))); + result.map(|_| ()) +} + +// Line 28 +fn c15_l28_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c15_l28_action_invoke"); + let result = instance.call("load_at_zero", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 29 +fn c16_l29_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c16_l29_action_invoke"); + let result = instance.call("store_at_zero", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 30 +fn c17_l30_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c17_l30_action_invoke"); + let result = instance.call("load_at_zero", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 31 +fn c18_l31_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c18_l31_action_invoke"); + let result = instance.call("load_at_page_size", &[]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 32 +fn c19_l32_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c19_l32_action_invoke"); + let result = instance.call("store_at_page_size", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 33 +fn c20_l33_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c20_l33_action_invoke"); + let result = instance.call("load_at_page_size", &[]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 36 + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l14_action_invoke(&mut instance); + c6_l19_action_invoke(&mut instance); + c7_l20_action_invoke(&mut instance); + c8_l21_action_invoke(&mut instance); + c9_l22_action_invoke(&mut instance); + c10_l23_action_invoke(&mut instance); + c13_l26_action_invoke(&mut instance); + c14_l27_action_invoke(&mut instance); + c15_l28_action_invoke(&mut instance); + c16_l29_action_invoke(&mut instance); + c17_l30_action_invoke(&mut instance); + c18_l31_action_invoke(&mut instance); + c19_l32_action_invoke(&mut instance); + c20_l33_action_invoke(&mut instance); +} +fn create_module_2() -> Box { + let module_str = "(module + (type (;0;) (func (param i32) (result i32))) + (func (;0;) (type 0) (param i32) (result i32) + get_local 0 + memory.grow) + (memory (;0;) 0) + (export \"grow\" (func 0))) + "; + 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_2(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 41 +fn c22_l41_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c22_l41_action_invoke"); + let result = instance.call("grow", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 42 +fn c23_l42_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c23_l42_action_invoke"); + let result = instance.call("grow", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 43 +fn c24_l43_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c24_l43_action_invoke"); + let result = instance.call("grow", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 44 +fn c25_l44_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c25_l44_action_invoke"); + let result = instance.call("grow", &[Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 45 +fn c26_l45_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c26_l45_action_invoke"); + let result = instance.call("grow", &[Value::I32(800 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 46 +fn c27_l46_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c27_l46_action_invoke"); + let result = instance.call("grow", &[Value::I32(65536 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 47 +fn c28_l47_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c28_l47_action_invoke"); + let result = instance.call("grow", &[Value::I32(64736 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 48 +fn c29_l48_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c29_l48_action_invoke"); + let result = instance.call("grow", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(803 as i32)))); + result.map(|_| ()) +} + +// Line 50 + +#[test] +fn test_module_2() { + let mut instance = create_module_2(); + // We group the calls together + start_module_2(&mut instance); + c22_l41_action_invoke(&mut instance); + c23_l42_action_invoke(&mut instance); + c24_l43_action_invoke(&mut instance); + c25_l44_action_invoke(&mut instance); + c26_l45_action_invoke(&mut instance); + c27_l46_action_invoke(&mut instance); + c28_l47_action_invoke(&mut instance); + c29_l48_action_invoke(&mut instance); +} +fn create_module_3() -> Box { + let module_str = "(module + (type (;0;) (func (param i32) (result i32))) + (func (;0;) (type 0) (param i32) (result i32) + get_local 0 + memory.grow) + (memory (;0;) 0 10) + (export \"grow\" (func 0))) + "; + 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_3(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 55 +fn c31_l55_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c31_l55_action_invoke"); + let result = instance.call("grow", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 56 +fn c32_l56_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c32_l56_action_invoke"); + let result = instance.call("grow", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 57 +fn c33_l57_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c33_l57_action_invoke"); + let result = instance.call("grow", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 58 +fn c34_l58_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c34_l58_action_invoke"); + let result = instance.call("grow", &[Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 59 +fn c35_l59_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c35_l59_action_invoke"); + let result = instance.call("grow", &[Value::I32(6 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(4 as i32)))); + result.map(|_| ()) +} + +// Line 60 +fn c36_l60_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c36_l60_action_invoke"); + let result = instance.call("grow", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); + result.map(|_| ()) +} + +// Line 61 +fn c37_l61_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c37_l61_action_invoke"); + let result = instance.call("grow", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 62 +fn c38_l62_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c38_l62_action_invoke"); + let result = instance.call("grow", &[Value::I32(65536 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 66 + +#[test] +fn test_module_3() { + let mut instance = create_module_3(); + // We group the calls together + start_module_3(&mut instance); + c31_l55_action_invoke(&mut instance); + c32_l56_action_invoke(&mut instance); + c33_l57_action_invoke(&mut instance); + c34_l58_action_invoke(&mut instance); + c35_l59_action_invoke(&mut instance); + c36_l60_action_invoke(&mut instance); + c37_l61_action_invoke(&mut instance); + c38_l62_action_invoke(&mut instance); +} +fn create_module_4() -> Box { + let module_str = "(module + (type (;0;) (func (param i32) (result i32))) + (type (;1;) (func (param i32 i32) (result i32))) + (func (;0;) (type 0) (param i32) (result i32) + get_local 0 + memory.grow) + (func (;1;) (type 1) (param i32 i32) (result i32) + (local i32) + i32.const 1 + set_local 2 + block ;; label = @1 + loop ;; label = @2 + get_local 0 + i32.load8_u + set_local 2 + get_local 2 + i32.const 0 + i32.ne + br_if 1 (;@1;) + get_local 0 + get_local 1 + i32.ge_u + br_if 1 (;@1;) + get_local 0 + i32.const 1 + i32.add + set_local 0 + get_local 0 + get_local 1 + i32.le_u + br_if 0 (;@2;) + end + end + get_local 2) + (memory (;0;) 1) + (export \"grow\" (func 0)) + (export \"check-memory-zero\" (func 1))) + "; + 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_4(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 87 +fn c40_l87_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c40_l87_action_invoke"); + let result = instance.call("check-memory-zero", &[Value::I32(0 as i32), Value::I32(65535 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 88 +fn c41_l88_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c41_l88_action_invoke"); + let result = instance.call("grow", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 89 +fn c42_l89_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c42_l89_action_invoke"); + let result = instance.call("check-memory-zero", &[Value::I32(65536 as i32), Value::I32(131071 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 90 +fn c43_l90_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c43_l90_action_invoke"); + let result = instance.call("grow", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 91 +fn c44_l91_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c44_l91_action_invoke"); + let result = instance.call("check-memory-zero", &[Value::I32(131072 as i32), Value::I32(196607 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 92 +fn c45_l92_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c45_l92_action_invoke"); + let result = instance.call("grow", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 93 +fn c46_l93_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c46_l93_action_invoke"); + let result = instance.call("check-memory-zero", &[Value::I32(196608 as i32), Value::I32(262143 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 94 +fn c47_l94_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c47_l94_action_invoke"); + let result = instance.call("grow", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(4 as i32)))); + result.map(|_| ()) +} + +// Line 95 +fn c48_l95_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c48_l95_action_invoke"); + let result = instance.call("check-memory-zero", &[Value::I32(262144 as i32), Value::I32(327679 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 96 +fn c49_l96_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c49_l96_action_invoke"); + let result = instance.call("grow", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(5 as i32)))); + result.map(|_| ()) +} + +// Line 97 +fn c50_l97_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c50_l97_action_invoke"); + let result = instance.call("check-memory-zero", &[Value::I32(327680 as i32), Value::I32(393215 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 101 + +#[test] +fn test_module_4() { + let mut instance = create_module_4(); + // We group the calls together + start_module_4(&mut instance); + c40_l87_action_invoke(&mut instance); + c41_l88_action_invoke(&mut instance); + c42_l89_action_invoke(&mut instance); + c43_l90_action_invoke(&mut instance); + c44_l91_action_invoke(&mut instance); + c45_l92_action_invoke(&mut instance); + c46_l93_action_invoke(&mut instance); + c47_l94_action_invoke(&mut instance); + c48_l95_action_invoke(&mut instance); + c49_l96_action_invoke(&mut instance); + c50_l97_action_invoke(&mut instance); +} +fn create_module_5() -> Box { + let module_str = "(module + (type (;0;) (func (param i32 i32 i32) (result i32))) + (type (;1;) (func (result i32))) + (type (;2;) (func)) + (type (;3;) (func (param i32 i32) (result i32))) + (func (;0;) (type 1) (result i32) + block (result i32) ;; label = @1 + i32.const 0 + memory.grow + br 0 (;@1;) + end) + (func (;1;) (type 2) + block ;; label = @1 + i32.const 0 + memory.grow + br_if 0 (;@1;) + end) + (func (;2;) (type 1) (result i32) + block (result i32) ;; label = @1 + i32.const 0 + memory.grow + i32.const 1 + br_if 0 (;@1;) + drop + i32.const 7 + end) + (func (;3;) (type 1) (result i32) + block (result i32) ;; label = @1 + i32.const 6 + i32.const 0 + memory.grow + br_if 0 (;@1;) + drop + i32.const 7 + end) + (func (;4;) (type 2) + block ;; label = @1 + i32.const 0 + memory.grow + br_table 0 (;@1;) 0 (;@1;) 0 (;@1;) + end) + (func (;5;) (type 1) (result i32) + block (result i32) ;; label = @1 + i32.const 0 + memory.grow + i32.const 1 + br_table 0 (;@1;) 0 (;@1;) 0 (;@1;) + i32.const 7 + end) + (func (;6;) (type 1) (result i32) + block (result i32) ;; label = @1 + i32.const 6 + i32.const 0 + memory.grow + br_table 0 (;@1;) 0 (;@1;) + i32.const 7 + end) + (func (;7;) (type 1) (result i32) + i32.const 0 + memory.grow + return) + (func (;8;) (type 1) (result i32) + i32.const 0 + memory.grow + if (result i32) ;; label = @1 + i32.const 0 + else + i32.const 1 + end) + (func (;9;) (type 1) (result i32) + i32.const 1 + if (result i32) ;; label = @1 + i32.const 0 + memory.grow + else + i32.const 0 + end) + (func (;10;) (type 1) (result i32) + i32.const 0 + if (result i32) ;; label = @1 + i32.const 0 + else + i32.const 0 + memory.grow + end) + (func (;11;) (type 3) (param i32 i32) (result i32) + i32.const 0 + memory.grow + get_local 0 + get_local 1 + select) + (func (;12;) (type 3) (param i32 i32) (result i32) + get_local 0 + i32.const 0 + memory.grow + get_local 1 + select) + (func (;13;) (type 1) (result i32) + i32.const 0 + i32.const 1 + i32.const 0 + memory.grow + select) + (func (;14;) (type 0) (param i32 i32 i32) (result i32) + i32.const -1) + (func (;15;) (type 1) (result i32) + i32.const 0 + memory.grow + i32.const 2 + i32.const 3 + call 14) + (func (;16;) (type 1) (result i32) + i32.const 1 + i32.const 0 + memory.grow + i32.const 3 + call 14) + (func (;17;) (type 1) (result i32) + i32.const 1 + i32.const 2 + i32.const 0 + memory.grow + call 14) + (func (;18;) (type 1) (result i32) + i32.const 0 + memory.grow + i32.const 2 + i32.const 3 + i32.const 0 + call_indirect (type 0)) + (func (;19;) (type 1) (result i32) + i32.const 1 + i32.const 0 + memory.grow + i32.const 3 + i32.const 0 + call_indirect (type 0)) + (func (;20;) (type 1) (result i32) + i32.const 1 + i32.const 2 + i32.const 0 + memory.grow + i32.const 0 + call_indirect (type 0)) + (func (;21;) (type 1) (result i32) + i32.const 1 + i32.const 2 + i32.const 3 + i32.const 0 + memory.grow + call_indirect (type 0)) + (func (;22;) (type 2) + (local i32) + i32.const 0 + memory.grow + set_local 0) + (func (;23;) (type 1) (result i32) + (local i32) + i32.const 0 + memory.grow + tee_local 0) + (func (;24;) (type 2) + (local i32) + i32.const 0 + memory.grow + set_global 0) + (func (;25;) (type 1) (result i32) + i32.const 0 + memory.grow + i32.load) + (func (;26;) (type 1) (result i32) + i32.const 0 + memory.grow + i32.load8_s) + (func (;27;) (type 2) + i32.const 0 + memory.grow + i32.const 7 + i32.store) + (func (;28;) (type 2) + i32.const 2 + i32.const 0 + memory.grow + i32.store) + (func (;29;) (type 2) + i32.const 0 + memory.grow + i32.const 7 + i32.store8) + (func (;30;) (type 2) + i32.const 2 + i32.const 0 + memory.grow + i32.store16) + (func (;31;) (type 1) (result i32) + i32.const 0 + memory.grow + i32.clz) + (func (;32;) (type 1) (result i32) + i32.const 0 + memory.grow + i32.const 10 + i32.add) + (func (;33;) (type 1) (result i32) + i32.const 10 + i32.const 0 + memory.grow + i32.sub) + (func (;34;) (type 1) (result i32) + i32.const 0 + memory.grow + i32.eqz) + (func (;35;) (type 1) (result i32) + i32.const 0 + memory.grow + i32.const 10 + i32.le_s) + (func (;36;) (type 1) (result i32) + i32.const 10 + i32.const 0 + memory.grow + i32.ne) + (func (;37;) (type 1) (result i32) + i32.const 0 + memory.grow + memory.grow) + (table (;0;) 1 1 anyfunc) + (memory (;0;) 1) + (global (;0;) (mut i32) (i32.const 0)) + (export \"as-br-value\" (func 0)) + (export \"as-br_if-cond\" (func 1)) + (export \"as-br_if-value\" (func 2)) + (export \"as-br_if-value-cond\" (func 3)) + (export \"as-br_table-index\" (func 4)) + (export \"as-br_table-value\" (func 5)) + (export \"as-br_table-value-index\" (func 6)) + (export \"as-return-value\" (func 7)) + (export \"as-if-cond\" (func 8)) + (export \"as-if-then\" (func 9)) + (export \"as-if-else\" (func 10)) + (export \"as-select-first\" (func 11)) + (export \"as-select-second\" (func 12)) + (export \"as-select-cond\" (func 13)) + (export \"as-call-first\" (func 15)) + (export \"as-call-mid\" (func 16)) + (export \"as-call-last\" (func 17)) + (export \"as-call_indirect-first\" (func 18)) + (export \"as-call_indirect-mid\" (func 19)) + (export \"as-call_indirect-last\" (func 20)) + (export \"as-call_indirect-index\" (func 21)) + (export \"as-set_local-value\" (func 22)) + (export \"as-tee_local-value\" (func 23)) + (export \"as-set_global-value\" (func 24)) + (export \"as-load-address\" (func 25)) + (export \"as-loadN-address\" (func 26)) + (export \"as-store-address\" (func 27)) + (export \"as-store-value\" (func 28)) + (export \"as-storeN-address\" (func 29)) + (export \"as-storeN-value\" (func 30)) + (export \"as-unary-operand\" (func 31)) + (export \"as-binary-left\" (func 32)) + (export \"as-binary-right\" (func 33)) + (export \"as-test-operand\" (func 34)) + (export \"as-compare-left\" (func 35)) + (export \"as-compare-right\" (func 36)) + (export \"as-memory.grow-size\" (func 37)) + (elem (;0;) (i32.const 0) 14)) + "; + 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_5(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 259 +fn c52_l259_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c52_l259_action_invoke"); + let result = instance.call("as-br-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 261 +fn c53_l261_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c53_l261_action_invoke"); + let result = instance.call("as-br_if-cond", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 262 +fn c54_l262_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c54_l262_action_invoke"); + let result = instance.call("as-br_if-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 263 +fn c55_l263_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c55_l263_action_invoke"); + let result = instance.call("as-br_if-value-cond", &[]); + assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); + result.map(|_| ()) +} + +// Line 265 +fn c56_l265_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c56_l265_action_invoke"); + let result = instance.call("as-br_table-index", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 266 +fn c57_l266_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c57_l266_action_invoke"); + let result = instance.call("as-br_table-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 267 +fn c58_l267_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c58_l267_action_invoke"); + let result = instance.call("as-br_table-value-index", &[]); + assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); + result.map(|_| ()) +} + +// Line 269 +fn c59_l269_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c59_l269_action_invoke"); + let result = instance.call("as-return-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 271 +fn c60_l271_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c60_l271_action_invoke"); + let result = instance.call("as-if-cond", &[]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 272 +fn c61_l272_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c61_l272_action_invoke"); + let result = instance.call("as-if-then", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 273 +fn c62_l273_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c62_l273_action_invoke"); + let result = instance.call("as-if-else", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 275 +fn c63_l275_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c63_l275_action_invoke"); + let result = instance.call("as-select-first", &[Value::I32(0 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 276 +fn c64_l276_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c64_l276_action_invoke"); + let result = instance.call("as-select-second", &[Value::I32(0 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 277 +fn c65_l277_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c65_l277_action_invoke"); + let result = instance.call("as-select-cond", &[]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 279 +fn c66_l279_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c66_l279_action_invoke"); + let result = instance.call("as-call-first", &[]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 280 +fn c67_l280_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c67_l280_action_invoke"); + let result = instance.call("as-call-mid", &[]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 281 +fn c68_l281_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c68_l281_action_invoke"); + let result = instance.call("as-call-last", &[]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 283 +fn c69_l283_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c69_l283_action_invoke"); + let result = instance.call("as-call_indirect-first", &[]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 284 +fn c70_l284_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c70_l284_action_invoke"); + let result = instance.call("as-call_indirect-mid", &[]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 285 +fn c71_l285_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c71_l285_action_invoke"); + let result = instance.call("as-call_indirect-last", &[]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 286 +fn c72_l286_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c72_l286_action_invoke"); + let result = instance.call("as-call_indirect-index", &[]); + + result.map(|_| ()) +} + +#[test] +fn c72_l286_assert_trap() { + let mut instance = create_module_5(); + let result = c72_l286_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 288 +fn c73_l288_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c73_l288_action_invoke"); + let result = instance.call("as-set_local-value", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 289 +fn c74_l289_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c74_l289_action_invoke"); + let result = instance.call("as-tee_local-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 290 +fn c75_l290_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c75_l290_action_invoke"); + let result = instance.call("as-set_global-value", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 292 +fn c76_l292_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c76_l292_action_invoke"); + let result = instance.call("as-load-address", &[]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 293 +fn c77_l293_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c77_l293_action_invoke"); + let result = instance.call("as-loadN-address", &[]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 294 +fn c78_l294_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c78_l294_action_invoke"); + let result = instance.call("as-store-address", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 295 +fn c79_l295_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c79_l295_action_invoke"); + let result = instance.call("as-store-value", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 296 +fn c80_l296_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c80_l296_action_invoke"); + let result = instance.call("as-storeN-address", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 297 +fn c81_l297_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c81_l297_action_invoke"); + let result = instance.call("as-storeN-value", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 299 +fn c82_l299_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c82_l299_action_invoke"); + let result = instance.call("as-unary-operand", &[]); + assert_eq!(result, Ok(Some(Value::I32(31 as i32)))); + result.map(|_| ()) +} + +// Line 301 +fn c83_l301_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c83_l301_action_invoke"); + let result = instance.call("as-binary-left", &[]); + assert_eq!(result, Ok(Some(Value::I32(11 as i32)))); + result.map(|_| ()) +} + +// Line 302 +fn c84_l302_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c84_l302_action_invoke"); + let result = instance.call("as-binary-right", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 304 +fn c85_l304_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c85_l304_action_invoke"); + let result = instance.call("as-test-operand", &[]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 306 +fn c86_l306_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c86_l306_action_invoke"); + let result = instance.call("as-compare-left", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 307 +fn c87_l307_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c87_l307_action_invoke"); + let result = instance.call("as-compare-right", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 309 +fn c88_l309_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c88_l309_action_invoke"); + let result = instance.call("as-memory.grow-size", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +#[test] +fn test_module_5() { + let mut instance = create_module_5(); + // We group the calls together + start_module_5(&mut instance); + c52_l259_action_invoke(&mut instance); + c53_l261_action_invoke(&mut instance); + c54_l262_action_invoke(&mut instance); + c55_l263_action_invoke(&mut instance); + c56_l265_action_invoke(&mut instance); + c57_l266_action_invoke(&mut instance); + c58_l267_action_invoke(&mut instance); + c59_l269_action_invoke(&mut instance); + c60_l271_action_invoke(&mut instance); + c61_l272_action_invoke(&mut instance); + c62_l273_action_invoke(&mut instance); + c63_l275_action_invoke(&mut instance); + c64_l276_action_invoke(&mut instance); + c65_l277_action_invoke(&mut instance); + c66_l279_action_invoke(&mut instance); + c67_l280_action_invoke(&mut instance); + c68_l281_action_invoke(&mut instance); + c69_l283_action_invoke(&mut instance); + c70_l284_action_invoke(&mut instance); + c71_l285_action_invoke(&mut instance); + c73_l288_action_invoke(&mut instance); + c74_l289_action_invoke(&mut instance); + c75_l290_action_invoke(&mut instance); + c76_l292_action_invoke(&mut instance); + c77_l293_action_invoke(&mut instance); + c78_l294_action_invoke(&mut instance); + c79_l295_action_invoke(&mut instance); + c80_l296_action_invoke(&mut instance); + c81_l297_action_invoke(&mut instance); + c82_l299_action_invoke(&mut instance); + c83_l301_action_invoke(&mut instance); + c84_l302_action_invoke(&mut instance); + c85_l304_action_invoke(&mut instance); + c86_l306_action_invoke(&mut instance); + c87_l307_action_invoke(&mut instance); + c88_l309_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/memory_redundancy.rs b/lib/runtime/tests/spectests/memory_redundancy.rs new file mode 100644 index 000000000..65cb113c5 --- /dev/null +++ b/lib/runtime/tests/spectests/memory_redundancy.rs @@ -0,0 +1,180 @@ +// 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/memory_redundancy.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 5 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func)) + (type (;1;) (func (result i32))) + (type (;2;) (func (result f32))) + (type (;3;) (func (param i32) (result i32))) + (func (;0;) (type 0) + i32.const 0 + i32.const 0 + i32.store + i32.const 4 + i32.const 0 + i32.store + i32.const 8 + i32.const 0 + i32.store + i32.const 12 + i32.const 0 + i32.store) + (func (;1;) (type 1) (result i32) + i32.const 8 + i32.const 0 + i32.store + i32.const 5 + f32.const -0x0p+0 (;=-0;) + f32.store + i32.const 8 + i32.load) + (func (;2;) (type 1) (result i32) + (local i32 i32) + i32.const 8 + i32.load + set_local 0 + i32.const 5 + i32.const -2147483648 + i32.store + i32.const 8 + i32.load + set_local 1 + get_local 0 + get_local 1 + i32.add) + (func (;3;) (type 2) (result f32) + (local f32) + i32.const 8 + i32.const 589505315 + i32.store + i32.const 11 + f32.load + set_local 0 + i32.const 8 + i32.const 0 + i32.store + get_local 0) + (func (;4;) (type 3) (param i32) (result i32) + i32.const 16) + (func (;5;) (type 1) (result i32) + (local i32 i32) + i32.const 4 + call 4 + set_local 0 + i32.const 4 + call 4 + set_local 1 + get_local 0 + i32.const 42 + i32.store + get_local 1 + i32.const 43 + i32.store + get_local 0 + i32.load) + (memory (;0;) 1 1) + (export \"zero_everything\" (func 0)) + (export \"test_store_to_load\" (func 1)) + (export \"test_redundant_load\" (func 2)) + (export \"test_dead_store\" (func 3)) + (export \"malloc\" (func 4)) + (export \"malloc_aliasing\" (func 5))) + "; + 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 59 +fn c1_l59_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l59_action_invoke"); + let result = instance.call("test_store_to_load", &[]); + assert_eq!(result, Ok(Some(Value::I32(128 as i32)))); + result.map(|_| ()) +} + +// Line 60 +fn c2_l60_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l60_action_invoke"); + let result = instance.call("zero_everything", &[]); + + result.map(|_| ()) +} + +// Line 61 +fn c3_l61_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l61_action_invoke"); + let result = instance.call("test_redundant_load", &[]); + assert_eq!(result, Ok(Some(Value::I32(128 as i32)))); + result.map(|_| ()) +} + +// Line 62 +fn c4_l62_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l62_action_invoke"); + let result = instance.call("zero_everything", &[]); + + result.map(|_| ()) +} + +// Line 63 +fn c5_l63_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l63_action_invoke"); + let result = instance.call("test_dead_store", &[]); + assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000049f32).to_bits())))); + result.map(|_| ()) +} + +// Line 64 +fn c6_l64_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l64_action_invoke"); + let result = instance.call("zero_everything", &[]); + + result.map(|_| ()) +} + +// Line 65 +fn c7_l65_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l65_action_invoke"); + let result = instance.call("malloc_aliasing", &[]); + assert_eq!(result, Ok(Some(Value::I32(43 as i32)))); + result.map(|_| ()) +} + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l59_action_invoke(&mut instance); + c2_l60_action_invoke(&mut instance); + c3_l61_action_invoke(&mut instance); + c4_l62_action_invoke(&mut instance); + c5_l63_action_invoke(&mut instance); + c6_l64_action_invoke(&mut instance); + c7_l65_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/memory_trap.rs b/lib/runtime/tests/spectests/memory_trap.rs new file mode 100644 index 000000000..826cb9c8d --- /dev/null +++ b/lib/runtime/tests/spectests/memory_trap.rs @@ -0,0 +1,2733 @@ +// 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/memory_trap.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 1 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func (result i32))) + (type (;1;) (func (param i32 i32))) + (type (;2;) (func (param i32) (result i32))) + (func (;0;) (type 0) (result i32) + memory.size + i32.const 65536 + i32.mul) + (func (;1;) (type 1) (param i32 i32) + call 0 + get_local 0 + i32.add + get_local 1 + i32.store) + (func (;2;) (type 2) (param i32) (result i32) + call 0 + get_local 0 + i32.add + i32.load) + (func (;3;) (type 2) (param i32) (result i32) + get_local 0 + memory.grow) + (memory (;0;) 1) + (export \"store\" (func 1)) + (export \"load\" (func 2)) + (export \"memory.grow\" (func 3))) + "; + 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 21 +fn c1_l21_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l21_action_invoke"); + let result = instance.call("store", &[Value::I32(-4 as i32), Value::I32(42 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 22 +fn c2_l22_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l22_action_invoke"); + let result = instance.call("load", &[Value::I32(-4 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(42 as i32)))); + result.map(|_| ()) +} + +// Line 23 +fn c3_l23_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l23_action_invoke"); + let result = instance.call("store", &[Value::I32(-3 as i32), Value::I32(13 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c3_l23_assert_trap() { + let mut instance = create_module_1(); + let result = c3_l23_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 24 +fn c4_l24_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l24_action_invoke"); + let result = instance.call("load", &[Value::I32(-3 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c4_l24_assert_trap() { + let mut instance = create_module_1(); + let result = c4_l24_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 25 +fn c5_l25_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l25_action_invoke"); + let result = instance.call("store", &[Value::I32(-2 as i32), Value::I32(13 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c5_l25_assert_trap() { + let mut instance = create_module_1(); + let result = c5_l25_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 26 +fn c6_l26_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l26_action_invoke"); + let result = instance.call("load", &[Value::I32(-2 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c6_l26_assert_trap() { + let mut instance = create_module_1(); + let result = c6_l26_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 27 +fn c7_l27_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l27_action_invoke"); + let result = instance.call("store", &[Value::I32(-1 as i32), Value::I32(13 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c7_l27_assert_trap() { + let mut instance = create_module_1(); + let result = c7_l27_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 28 +fn c8_l28_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l28_action_invoke"); + let result = instance.call("load", &[Value::I32(-1 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c8_l28_assert_trap() { + let mut instance = create_module_1(); + let result = c8_l28_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 29 +fn c9_l29_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l29_action_invoke"); + let result = instance.call("store", &[Value::I32(0 as i32), Value::I32(13 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c9_l29_assert_trap() { + let mut instance = create_module_1(); + let result = c9_l29_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 30 +fn c10_l30_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c10_l30_action_invoke"); + let result = instance.call("load", &[Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c10_l30_assert_trap() { + let mut instance = create_module_1(); + let result = c10_l30_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 31 +fn c11_l31_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c11_l31_action_invoke"); + let result = instance.call("store", &[Value::I32(-2147483648 as i32), Value::I32(13 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c11_l31_assert_trap() { + let mut instance = create_module_1(); + let result = c11_l31_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 32 +fn c12_l32_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c12_l32_action_invoke"); + let result = instance.call("load", &[Value::I32(-2147483648 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c12_l32_assert_trap() { + let mut instance = create_module_1(); + let result = c12_l32_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 33 +fn c13_l33_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c13_l33_action_invoke"); + let result = instance.call("memory.grow", &[Value::I32(65537 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 35 + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l21_action_invoke(&mut instance); + c2_l22_action_invoke(&mut instance); + c13_l33_action_invoke(&mut instance); +} +fn create_module_2() -> Box { + let module_str = "(module + (type (;0;) (func (param i32) (result i32))) + (type (;1;) (func (param i32) (result i64))) + (type (;2;) (func (param i32) (result f32))) + (type (;3;) (func (param i32) (result f64))) + (type (;4;) (func (param i32 i32))) + (type (;5;) (func (param i32 i64))) + (type (;6;) (func (param i32 f32))) + (type (;7;) (func (param i32 f64))) + (func (;0;) (type 0) (param i32) (result i32) + get_local 0 + i32.load) + (func (;1;) (type 1) (param i32) (result i64) + get_local 0 + i64.load) + (func (;2;) (type 2) (param i32) (result f32) + get_local 0 + f32.load) + (func (;3;) (type 3) (param i32) (result f64) + get_local 0 + f64.load) + (func (;4;) (type 0) (param i32) (result i32) + get_local 0 + i32.load8_s) + (func (;5;) (type 0) (param i32) (result i32) + get_local 0 + i32.load8_u) + (func (;6;) (type 0) (param i32) (result i32) + get_local 0 + i32.load16_s) + (func (;7;) (type 0) (param i32) (result i32) + get_local 0 + i32.load16_u) + (func (;8;) (type 1) (param i32) (result i64) + get_local 0 + i64.load8_s) + (func (;9;) (type 1) (param i32) (result i64) + get_local 0 + i64.load8_u) + (func (;10;) (type 1) (param i32) (result i64) + get_local 0 + i64.load16_s) + (func (;11;) (type 1) (param i32) (result i64) + get_local 0 + i64.load16_u) + (func (;12;) (type 1) (param i32) (result i64) + get_local 0 + i64.load32_s) + (func (;13;) (type 1) (param i32) (result i64) + get_local 0 + i64.load32_u) + (func (;14;) (type 4) (param i32 i32) + get_local 0 + get_local 1 + i32.store) + (func (;15;) (type 5) (param i32 i64) + get_local 0 + get_local 1 + i64.store) + (func (;16;) (type 6) (param i32 f32) + get_local 0 + get_local 1 + f32.store) + (func (;17;) (type 7) (param i32 f64) + get_local 0 + get_local 1 + f64.store) + (func (;18;) (type 4) (param i32 i32) + get_local 0 + get_local 1 + i32.store8) + (func (;19;) (type 4) (param i32 i32) + get_local 0 + get_local 1 + i32.store16) + (func (;20;) (type 5) (param i32 i64) + get_local 0 + get_local 1 + i64.store8) + (func (;21;) (type 5) (param i32 i64) + get_local 0 + get_local 1 + i64.store16) + (func (;22;) (type 5) (param i32 i64) + get_local 0 + get_local 1 + i64.store32) + (memory (;0;) 1) + (export \"i32.load\" (func 0)) + (export \"i64.load\" (func 1)) + (export \"f32.load\" (func 2)) + (export \"f64.load\" (func 3)) + (export \"i32.load8_s\" (func 4)) + (export \"i32.load8_u\" (func 5)) + (export \"i32.load16_s\" (func 6)) + (export \"i32.load16_u\" (func 7)) + (export \"i64.load8_s\" (func 8)) + (export \"i64.load8_u\" (func 9)) + (export \"i64.load16_s\" (func 10)) + (export \"i64.load16_u\" (func 11)) + (export \"i64.load32_s\" (func 12)) + (export \"i64.load32_u\" (func 13)) + (export \"i32.store\" (func 14)) + (export \"i64.store\" (func 15)) + (export \"f32.store\" (func 16)) + (export \"f64.store\" (func 17)) + (export \"i32.store8\" (func 18)) + (export \"i32.store16\" (func 19)) + (export \"i64.store8\" (func 20)) + (export \"i64.store16\" (func 21)) + (export \"i64.store32\" (func 22)) + (data (;0;) (i32.const 0) \"abcdefgh\") + (data (;1;) (i32.const 65528) \"abcdefgh\")) + "; + 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_2(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 111 +fn c15_l111_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c15_l111_action_invoke"); + let result = instance.call("i32.store", &[Value::I32(65536 as i32), Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c15_l111_assert_trap() { + let mut instance = create_module_2(); + let result = c15_l111_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 112 +fn c16_l112_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c16_l112_action_invoke"); + let result = instance.call("i32.store", &[Value::I32(65535 as i32), Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c16_l112_assert_trap() { + let mut instance = create_module_2(); + let result = c16_l112_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 113 +fn c17_l113_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c17_l113_action_invoke"); + let result = instance.call("i32.store", &[Value::I32(65534 as i32), Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c17_l113_assert_trap() { + let mut instance = create_module_2(); + let result = c17_l113_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 114 +fn c18_l114_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c18_l114_action_invoke"); + let result = instance.call("i32.store", &[Value::I32(65533 as i32), Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c18_l114_assert_trap() { + let mut instance = create_module_2(); + let result = c18_l114_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 115 +fn c19_l115_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c19_l115_action_invoke"); + let result = instance.call("i32.store", &[Value::I32(-1 as i32), Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c19_l115_assert_trap() { + let mut instance = create_module_2(); + let result = c19_l115_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 116 +fn c20_l116_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c20_l116_action_invoke"); + let result = instance.call("i32.store", &[Value::I32(-2 as i32), Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c20_l116_assert_trap() { + let mut instance = create_module_2(); + let result = c20_l116_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 117 +fn c21_l117_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c21_l117_action_invoke"); + let result = instance.call("i32.store", &[Value::I32(-3 as i32), Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c21_l117_assert_trap() { + let mut instance = create_module_2(); + let result = c21_l117_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 118 +fn c22_l118_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c22_l118_action_invoke"); + let result = instance.call("i32.store", &[Value::I32(-4 as i32), Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c22_l118_assert_trap() { + let mut instance = create_module_2(); + let result = c22_l118_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 119 +fn c23_l119_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c23_l119_action_invoke"); + let result = instance.call("i64.store", &[Value::I32(65536 as i32), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c23_l119_assert_trap() { + let mut instance = create_module_2(); + let result = c23_l119_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 120 +fn c24_l120_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c24_l120_action_invoke"); + let result = instance.call("i64.store", &[Value::I32(65535 as i32), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c24_l120_assert_trap() { + let mut instance = create_module_2(); + let result = c24_l120_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 121 +fn c25_l121_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c25_l121_action_invoke"); + let result = instance.call("i64.store", &[Value::I32(65534 as i32), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c25_l121_assert_trap() { + let mut instance = create_module_2(); + let result = c25_l121_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 122 +fn c26_l122_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c26_l122_action_invoke"); + let result = instance.call("i64.store", &[Value::I32(65533 as i32), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c26_l122_assert_trap() { + let mut instance = create_module_2(); + let result = c26_l122_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 123 +fn c27_l123_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c27_l123_action_invoke"); + let result = instance.call("i64.store", &[Value::I32(65532 as i32), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c27_l123_assert_trap() { + let mut instance = create_module_2(); + let result = c27_l123_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 124 +fn c28_l124_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c28_l124_action_invoke"); + let result = instance.call("i64.store", &[Value::I32(65531 as i32), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c28_l124_assert_trap() { + let mut instance = create_module_2(); + let result = c28_l124_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 125 +fn c29_l125_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c29_l125_action_invoke"); + let result = instance.call("i64.store", &[Value::I32(65530 as i32), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c29_l125_assert_trap() { + let mut instance = create_module_2(); + let result = c29_l125_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 126 +fn c30_l126_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c30_l126_action_invoke"); + let result = instance.call("i64.store", &[Value::I32(65529 as i32), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c30_l126_assert_trap() { + let mut instance = create_module_2(); + let result = c30_l126_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 127 +fn c31_l127_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c31_l127_action_invoke"); + let result = instance.call("i64.store", &[Value::I32(-1 as i32), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c31_l127_assert_trap() { + let mut instance = create_module_2(); + let result = c31_l127_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 128 +fn c32_l128_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c32_l128_action_invoke"); + let result = instance.call("i64.store", &[Value::I32(-2 as i32), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c32_l128_assert_trap() { + let mut instance = create_module_2(); + let result = c32_l128_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 129 +fn c33_l129_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c33_l129_action_invoke"); + let result = instance.call("i64.store", &[Value::I32(-3 as i32), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c33_l129_assert_trap() { + let mut instance = create_module_2(); + let result = c33_l129_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 130 +fn c34_l130_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c34_l130_action_invoke"); + let result = instance.call("i64.store", &[Value::I32(-4 as i32), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c34_l130_assert_trap() { + let mut instance = create_module_2(); + let result = c34_l130_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 131 +fn c35_l131_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c35_l131_action_invoke"); + let result = instance.call("i64.store", &[Value::I32(-5 as i32), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c35_l131_assert_trap() { + let mut instance = create_module_2(); + let result = c35_l131_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 132 +fn c36_l132_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c36_l132_action_invoke"); + let result = instance.call("i64.store", &[Value::I32(-6 as i32), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c36_l132_assert_trap() { + let mut instance = create_module_2(); + let result = c36_l132_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 133 +fn c37_l133_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c37_l133_action_invoke"); + let result = instance.call("i64.store", &[Value::I32(-7 as i32), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c37_l133_assert_trap() { + let mut instance = create_module_2(); + let result = c37_l133_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 134 +fn c38_l134_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c38_l134_action_invoke"); + let result = instance.call("i64.store", &[Value::I32(-8 as i32), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c38_l134_assert_trap() { + let mut instance = create_module_2(); + let result = c38_l134_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 135 +fn c39_l135_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c39_l135_action_invoke"); + let result = instance.call("f32.store", &[Value::I32(65536 as i32), Value::F32((0.0f32).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c39_l135_assert_trap() { + let mut instance = create_module_2(); + let result = c39_l135_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 136 +fn c40_l136_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c40_l136_action_invoke"); + let result = instance.call("f32.store", &[Value::I32(65535 as i32), Value::F32((0.0f32).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c40_l136_assert_trap() { + let mut instance = create_module_2(); + let result = c40_l136_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 137 +fn c41_l137_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c41_l137_action_invoke"); + let result = instance.call("f32.store", &[Value::I32(65534 as i32), Value::F32((0.0f32).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c41_l137_assert_trap() { + let mut instance = create_module_2(); + let result = c41_l137_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 138 +fn c42_l138_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c42_l138_action_invoke"); + let result = instance.call("f32.store", &[Value::I32(65533 as i32), Value::F32((0.0f32).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c42_l138_assert_trap() { + let mut instance = create_module_2(); + let result = c42_l138_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 139 +fn c43_l139_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c43_l139_action_invoke"); + let result = instance.call("f32.store", &[Value::I32(-1 as i32), Value::F32((0.0f32).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c43_l139_assert_trap() { + let mut instance = create_module_2(); + let result = c43_l139_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 140 +fn c44_l140_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c44_l140_action_invoke"); + let result = instance.call("f32.store", &[Value::I32(-2 as i32), Value::F32((0.0f32).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c44_l140_assert_trap() { + let mut instance = create_module_2(); + let result = c44_l140_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 141 +fn c45_l141_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c45_l141_action_invoke"); + let result = instance.call("f32.store", &[Value::I32(-3 as i32), Value::F32((0.0f32).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c45_l141_assert_trap() { + let mut instance = create_module_2(); + let result = c45_l141_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 142 +fn c46_l142_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c46_l142_action_invoke"); + let result = instance.call("f32.store", &[Value::I32(-4 as i32), Value::F32((0.0f32).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c46_l142_assert_trap() { + let mut instance = create_module_2(); + let result = c46_l142_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 143 +fn c47_l143_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c47_l143_action_invoke"); + let result = instance.call("f64.store", &[Value::I32(65536 as i32), Value::F64((0.0f64).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c47_l143_assert_trap() { + let mut instance = create_module_2(); + let result = c47_l143_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 144 +fn c48_l144_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c48_l144_action_invoke"); + let result = instance.call("f64.store", &[Value::I32(65535 as i32), Value::F64((0.0f64).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c48_l144_assert_trap() { + let mut instance = create_module_2(); + let result = c48_l144_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 145 +fn c49_l145_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c49_l145_action_invoke"); + let result = instance.call("f64.store", &[Value::I32(65534 as i32), Value::F64((0.0f64).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c49_l145_assert_trap() { + let mut instance = create_module_2(); + let result = c49_l145_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 146 +fn c50_l146_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c50_l146_action_invoke"); + let result = instance.call("f64.store", &[Value::I32(65533 as i32), Value::F64((0.0f64).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c50_l146_assert_trap() { + let mut instance = create_module_2(); + let result = c50_l146_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 147 +fn c51_l147_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c51_l147_action_invoke"); + let result = instance.call("f64.store", &[Value::I32(65532 as i32), Value::F64((0.0f64).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c51_l147_assert_trap() { + let mut instance = create_module_2(); + let result = c51_l147_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 148 +fn c52_l148_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c52_l148_action_invoke"); + let result = instance.call("f64.store", &[Value::I32(65531 as i32), Value::F64((0.0f64).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c52_l148_assert_trap() { + let mut instance = create_module_2(); + let result = c52_l148_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 149 +fn c53_l149_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c53_l149_action_invoke"); + let result = instance.call("f64.store", &[Value::I32(65530 as i32), Value::F64((0.0f64).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c53_l149_assert_trap() { + let mut instance = create_module_2(); + let result = c53_l149_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 150 +fn c54_l150_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c54_l150_action_invoke"); + let result = instance.call("f64.store", &[Value::I32(65529 as i32), Value::F64((0.0f64).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c54_l150_assert_trap() { + let mut instance = create_module_2(); + let result = c54_l150_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 151 +fn c55_l151_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c55_l151_action_invoke"); + let result = instance.call("f64.store", &[Value::I32(-1 as i32), Value::F64((0.0f64).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c55_l151_assert_trap() { + let mut instance = create_module_2(); + let result = c55_l151_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 152 +fn c56_l152_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c56_l152_action_invoke"); + let result = instance.call("f64.store", &[Value::I32(-2 as i32), Value::F64((0.0f64).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c56_l152_assert_trap() { + let mut instance = create_module_2(); + let result = c56_l152_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 153 +fn c57_l153_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c57_l153_action_invoke"); + let result = instance.call("f64.store", &[Value::I32(-3 as i32), Value::F64((0.0f64).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c57_l153_assert_trap() { + let mut instance = create_module_2(); + let result = c57_l153_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 154 +fn c58_l154_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c58_l154_action_invoke"); + let result = instance.call("f64.store", &[Value::I32(-4 as i32), Value::F64((0.0f64).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c58_l154_assert_trap() { + let mut instance = create_module_2(); + let result = c58_l154_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 155 +fn c59_l155_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c59_l155_action_invoke"); + let result = instance.call("f64.store", &[Value::I32(-5 as i32), Value::F64((0.0f64).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c59_l155_assert_trap() { + let mut instance = create_module_2(); + let result = c59_l155_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 156 +fn c60_l156_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c60_l156_action_invoke"); + let result = instance.call("f64.store", &[Value::I32(-6 as i32), Value::F64((0.0f64).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c60_l156_assert_trap() { + let mut instance = create_module_2(); + let result = c60_l156_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 157 +fn c61_l157_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c61_l157_action_invoke"); + let result = instance.call("f64.store", &[Value::I32(-7 as i32), Value::F64((0.0f64).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c61_l157_assert_trap() { + let mut instance = create_module_2(); + let result = c61_l157_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 158 +fn c62_l158_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c62_l158_action_invoke"); + let result = instance.call("f64.store", &[Value::I32(-8 as i32), Value::F64((0.0f64).to_bits())]); + + result.map(|_| ()) +} + +#[test] +fn c62_l158_assert_trap() { + let mut instance = create_module_2(); + let result = c62_l158_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 159 +fn c63_l159_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c63_l159_action_invoke"); + let result = instance.call("i32.store8", &[Value::I32(65536 as i32), Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c63_l159_assert_trap() { + let mut instance = create_module_2(); + let result = c63_l159_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 160 +fn c64_l160_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c64_l160_action_invoke"); + let result = instance.call("i32.store8", &[Value::I32(-1 as i32), Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c64_l160_assert_trap() { + let mut instance = create_module_2(); + let result = c64_l160_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 161 +fn c65_l161_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c65_l161_action_invoke"); + let result = instance.call("i32.store16", &[Value::I32(65536 as i32), Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c65_l161_assert_trap() { + let mut instance = create_module_2(); + let result = c65_l161_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 162 +fn c66_l162_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c66_l162_action_invoke"); + let result = instance.call("i32.store16", &[Value::I32(65535 as i32), Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c66_l162_assert_trap() { + let mut instance = create_module_2(); + let result = c66_l162_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 163 +fn c67_l163_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c67_l163_action_invoke"); + let result = instance.call("i32.store16", &[Value::I32(-1 as i32), Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c67_l163_assert_trap() { + let mut instance = create_module_2(); + let result = c67_l163_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 164 +fn c68_l164_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c68_l164_action_invoke"); + let result = instance.call("i32.store16", &[Value::I32(-2 as i32), Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c68_l164_assert_trap() { + let mut instance = create_module_2(); + let result = c68_l164_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 165 +fn c69_l165_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c69_l165_action_invoke"); + let result = instance.call("i64.store8", &[Value::I32(65536 as i32), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c69_l165_assert_trap() { + let mut instance = create_module_2(); + let result = c69_l165_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 166 +fn c70_l166_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c70_l166_action_invoke"); + let result = instance.call("i64.store8", &[Value::I32(-1 as i32), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c70_l166_assert_trap() { + let mut instance = create_module_2(); + let result = c70_l166_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 167 +fn c71_l167_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c71_l167_action_invoke"); + let result = instance.call("i64.store16", &[Value::I32(65536 as i32), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c71_l167_assert_trap() { + let mut instance = create_module_2(); + let result = c71_l167_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 168 +fn c72_l168_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c72_l168_action_invoke"); + let result = instance.call("i64.store16", &[Value::I32(65535 as i32), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c72_l168_assert_trap() { + let mut instance = create_module_2(); + let result = c72_l168_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 169 +fn c73_l169_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c73_l169_action_invoke"); + let result = instance.call("i64.store16", &[Value::I32(-1 as i32), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c73_l169_assert_trap() { + let mut instance = create_module_2(); + let result = c73_l169_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 170 +fn c74_l170_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c74_l170_action_invoke"); + let result = instance.call("i64.store16", &[Value::I32(-2 as i32), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c74_l170_assert_trap() { + let mut instance = create_module_2(); + let result = c74_l170_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 171 +fn c75_l171_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c75_l171_action_invoke"); + let result = instance.call("i64.store32", &[Value::I32(65536 as i32), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c75_l171_assert_trap() { + let mut instance = create_module_2(); + let result = c75_l171_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 172 +fn c76_l172_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c76_l172_action_invoke"); + let result = instance.call("i64.store32", &[Value::I32(65535 as i32), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c76_l172_assert_trap() { + let mut instance = create_module_2(); + let result = c76_l172_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 173 +fn c77_l173_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c77_l173_action_invoke"); + let result = instance.call("i64.store32", &[Value::I32(65534 as i32), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c77_l173_assert_trap() { + let mut instance = create_module_2(); + let result = c77_l173_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 174 +fn c78_l174_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c78_l174_action_invoke"); + let result = instance.call("i64.store32", &[Value::I32(65533 as i32), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c78_l174_assert_trap() { + let mut instance = create_module_2(); + let result = c78_l174_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 175 +fn c79_l175_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c79_l175_action_invoke"); + let result = instance.call("i64.store32", &[Value::I32(-1 as i32), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c79_l175_assert_trap() { + let mut instance = create_module_2(); + let result = c79_l175_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 176 +fn c80_l176_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c80_l176_action_invoke"); + let result = instance.call("i64.store32", &[Value::I32(-2 as i32), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c80_l176_assert_trap() { + let mut instance = create_module_2(); + let result = c80_l176_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 177 +fn c81_l177_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c81_l177_action_invoke"); + let result = instance.call("i64.store32", &[Value::I32(-3 as i32), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c81_l177_assert_trap() { + let mut instance = create_module_2(); + let result = c81_l177_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 178 +fn c82_l178_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c82_l178_action_invoke"); + let result = instance.call("i64.store32", &[Value::I32(-4 as i32), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c82_l178_assert_trap() { + let mut instance = create_module_2(); + let result = c82_l178_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 179 +fn c83_l179_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c83_l179_action_invoke"); + let result = instance.call("i32.load", &[Value::I32(65536 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c83_l179_assert_trap() { + let mut instance = create_module_2(); + let result = c83_l179_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 180 +fn c84_l180_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c84_l180_action_invoke"); + let result = instance.call("i32.load", &[Value::I32(65535 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c84_l180_assert_trap() { + let mut instance = create_module_2(); + let result = c84_l180_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 181 +fn c85_l181_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c85_l181_action_invoke"); + let result = instance.call("i32.load", &[Value::I32(65534 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c85_l181_assert_trap() { + let mut instance = create_module_2(); + let result = c85_l181_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 182 +fn c86_l182_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c86_l182_action_invoke"); + let result = instance.call("i32.load", &[Value::I32(65533 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c86_l182_assert_trap() { + let mut instance = create_module_2(); + let result = c86_l182_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 183 +fn c87_l183_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c87_l183_action_invoke"); + let result = instance.call("i32.load", &[Value::I32(-1 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c87_l183_assert_trap() { + let mut instance = create_module_2(); + let result = c87_l183_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 184 +fn c88_l184_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c88_l184_action_invoke"); + let result = instance.call("i32.load", &[Value::I32(-2 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c88_l184_assert_trap() { + let mut instance = create_module_2(); + let result = c88_l184_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 185 +fn c89_l185_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c89_l185_action_invoke"); + let result = instance.call("i32.load", &[Value::I32(-3 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c89_l185_assert_trap() { + let mut instance = create_module_2(); + let result = c89_l185_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 186 +fn c90_l186_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c90_l186_action_invoke"); + let result = instance.call("i32.load", &[Value::I32(-4 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c90_l186_assert_trap() { + let mut instance = create_module_2(); + let result = c90_l186_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 187 +fn c91_l187_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c91_l187_action_invoke"); + let result = instance.call("i64.load", &[Value::I32(65536 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c91_l187_assert_trap() { + let mut instance = create_module_2(); + let result = c91_l187_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 188 +fn c92_l188_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c92_l188_action_invoke"); + let result = instance.call("i64.load", &[Value::I32(65535 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c92_l188_assert_trap() { + let mut instance = create_module_2(); + let result = c92_l188_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 189 +fn c93_l189_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c93_l189_action_invoke"); + let result = instance.call("i64.load", &[Value::I32(65534 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c93_l189_assert_trap() { + let mut instance = create_module_2(); + let result = c93_l189_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 190 +fn c94_l190_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c94_l190_action_invoke"); + let result = instance.call("i64.load", &[Value::I32(65533 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c94_l190_assert_trap() { + let mut instance = create_module_2(); + let result = c94_l190_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 191 +fn c95_l191_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c95_l191_action_invoke"); + let result = instance.call("i64.load", &[Value::I32(65532 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c95_l191_assert_trap() { + let mut instance = create_module_2(); + let result = c95_l191_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 192 +fn c96_l192_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c96_l192_action_invoke"); + let result = instance.call("i64.load", &[Value::I32(65531 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c96_l192_assert_trap() { + let mut instance = create_module_2(); + let result = c96_l192_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 193 +fn c97_l193_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c97_l193_action_invoke"); + let result = instance.call("i64.load", &[Value::I32(65530 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c97_l193_assert_trap() { + let mut instance = create_module_2(); + let result = c97_l193_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 194 +fn c98_l194_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c98_l194_action_invoke"); + let result = instance.call("i64.load", &[Value::I32(65529 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c98_l194_assert_trap() { + let mut instance = create_module_2(); + let result = c98_l194_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 195 +fn c99_l195_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c99_l195_action_invoke"); + let result = instance.call("i64.load", &[Value::I32(-1 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c99_l195_assert_trap() { + let mut instance = create_module_2(); + let result = c99_l195_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 196 +fn c100_l196_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c100_l196_action_invoke"); + let result = instance.call("i64.load", &[Value::I32(-2 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c100_l196_assert_trap() { + let mut instance = create_module_2(); + let result = c100_l196_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 197 +fn c101_l197_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c101_l197_action_invoke"); + let result = instance.call("i64.load", &[Value::I32(-3 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c101_l197_assert_trap() { + let mut instance = create_module_2(); + let result = c101_l197_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 198 +fn c102_l198_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c102_l198_action_invoke"); + let result = instance.call("i64.load", &[Value::I32(-4 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c102_l198_assert_trap() { + let mut instance = create_module_2(); + let result = c102_l198_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 199 +fn c103_l199_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c103_l199_action_invoke"); + let result = instance.call("i64.load", &[Value::I32(-5 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c103_l199_assert_trap() { + let mut instance = create_module_2(); + let result = c103_l199_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 200 +fn c104_l200_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c104_l200_action_invoke"); + let result = instance.call("i64.load", &[Value::I32(-6 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c104_l200_assert_trap() { + let mut instance = create_module_2(); + let result = c104_l200_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 201 +fn c105_l201_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c105_l201_action_invoke"); + let result = instance.call("i64.load", &[Value::I32(-7 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c105_l201_assert_trap() { + let mut instance = create_module_2(); + let result = c105_l201_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 202 +fn c106_l202_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c106_l202_action_invoke"); + let result = instance.call("i64.load", &[Value::I32(-8 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c106_l202_assert_trap() { + let mut instance = create_module_2(); + let result = c106_l202_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 203 +fn c107_l203_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c107_l203_action_invoke"); + let result = instance.call("f32.load", &[Value::I32(65536 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c107_l203_assert_trap() { + let mut instance = create_module_2(); + let result = c107_l203_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 204 +fn c108_l204_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c108_l204_action_invoke"); + let result = instance.call("f32.load", &[Value::I32(65535 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c108_l204_assert_trap() { + let mut instance = create_module_2(); + let result = c108_l204_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 205 +fn c109_l205_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c109_l205_action_invoke"); + let result = instance.call("f32.load", &[Value::I32(65534 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c109_l205_assert_trap() { + let mut instance = create_module_2(); + let result = c109_l205_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 206 +fn c110_l206_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c110_l206_action_invoke"); + let result = instance.call("f32.load", &[Value::I32(65533 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c110_l206_assert_trap() { + let mut instance = create_module_2(); + let result = c110_l206_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 207 +fn c111_l207_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c111_l207_action_invoke"); + let result = instance.call("f32.load", &[Value::I32(-1 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c111_l207_assert_trap() { + let mut instance = create_module_2(); + let result = c111_l207_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 208 +fn c112_l208_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c112_l208_action_invoke"); + let result = instance.call("f32.load", &[Value::I32(-2 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c112_l208_assert_trap() { + let mut instance = create_module_2(); + let result = c112_l208_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 209 +fn c113_l209_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c113_l209_action_invoke"); + let result = instance.call("f32.load", &[Value::I32(-3 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c113_l209_assert_trap() { + let mut instance = create_module_2(); + let result = c113_l209_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 210 +fn c114_l210_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c114_l210_action_invoke"); + let result = instance.call("f32.load", &[Value::I32(-4 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c114_l210_assert_trap() { + let mut instance = create_module_2(); + let result = c114_l210_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 211 +fn c115_l211_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c115_l211_action_invoke"); + let result = instance.call("f64.load", &[Value::I32(65536 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c115_l211_assert_trap() { + let mut instance = create_module_2(); + let result = c115_l211_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 212 +fn c116_l212_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c116_l212_action_invoke"); + let result = instance.call("f64.load", &[Value::I32(65535 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c116_l212_assert_trap() { + let mut instance = create_module_2(); + let result = c116_l212_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 213 +fn c117_l213_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c117_l213_action_invoke"); + let result = instance.call("f64.load", &[Value::I32(65534 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c117_l213_assert_trap() { + let mut instance = create_module_2(); + let result = c117_l213_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 214 +fn c118_l214_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c118_l214_action_invoke"); + let result = instance.call("f64.load", &[Value::I32(65533 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c118_l214_assert_trap() { + let mut instance = create_module_2(); + let result = c118_l214_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 215 +fn c119_l215_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c119_l215_action_invoke"); + let result = instance.call("f64.load", &[Value::I32(65532 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c119_l215_assert_trap() { + let mut instance = create_module_2(); + let result = c119_l215_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 216 +fn c120_l216_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c120_l216_action_invoke"); + let result = instance.call("f64.load", &[Value::I32(65531 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c120_l216_assert_trap() { + let mut instance = create_module_2(); + let result = c120_l216_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 217 +fn c121_l217_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c121_l217_action_invoke"); + let result = instance.call("f64.load", &[Value::I32(65530 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c121_l217_assert_trap() { + let mut instance = create_module_2(); + let result = c121_l217_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 218 +fn c122_l218_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c122_l218_action_invoke"); + let result = instance.call("f64.load", &[Value::I32(65529 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c122_l218_assert_trap() { + let mut instance = create_module_2(); + let result = c122_l218_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 219 +fn c123_l219_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c123_l219_action_invoke"); + let result = instance.call("f64.load", &[Value::I32(-1 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c123_l219_assert_trap() { + let mut instance = create_module_2(); + let result = c123_l219_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 220 +fn c124_l220_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c124_l220_action_invoke"); + let result = instance.call("f64.load", &[Value::I32(-2 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c124_l220_assert_trap() { + let mut instance = create_module_2(); + let result = c124_l220_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 221 +fn c125_l221_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c125_l221_action_invoke"); + let result = instance.call("f64.load", &[Value::I32(-3 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c125_l221_assert_trap() { + let mut instance = create_module_2(); + let result = c125_l221_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 222 +fn c126_l222_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c126_l222_action_invoke"); + let result = instance.call("f64.load", &[Value::I32(-4 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c126_l222_assert_trap() { + let mut instance = create_module_2(); + let result = c126_l222_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 223 +fn c127_l223_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c127_l223_action_invoke"); + let result = instance.call("f64.load", &[Value::I32(-5 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c127_l223_assert_trap() { + let mut instance = create_module_2(); + let result = c127_l223_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 224 +fn c128_l224_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c128_l224_action_invoke"); + let result = instance.call("f64.load", &[Value::I32(-6 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c128_l224_assert_trap() { + let mut instance = create_module_2(); + let result = c128_l224_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 225 +fn c129_l225_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c129_l225_action_invoke"); + let result = instance.call("f64.load", &[Value::I32(-7 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c129_l225_assert_trap() { + let mut instance = create_module_2(); + let result = c129_l225_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 226 +fn c130_l226_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c130_l226_action_invoke"); + let result = instance.call("f64.load", &[Value::I32(-8 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c130_l226_assert_trap() { + let mut instance = create_module_2(); + let result = c130_l226_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 227 +fn c131_l227_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c131_l227_action_invoke"); + let result = instance.call("i32.load8_s", &[Value::I32(65536 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c131_l227_assert_trap() { + let mut instance = create_module_2(); + let result = c131_l227_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 228 +fn c132_l228_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c132_l228_action_invoke"); + let result = instance.call("i32.load8_s", &[Value::I32(-1 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c132_l228_assert_trap() { + let mut instance = create_module_2(); + let result = c132_l228_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 229 +fn c133_l229_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c133_l229_action_invoke"); + let result = instance.call("i32.load8_u", &[Value::I32(65536 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c133_l229_assert_trap() { + let mut instance = create_module_2(); + let result = c133_l229_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 230 +fn c134_l230_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c134_l230_action_invoke"); + let result = instance.call("i32.load8_u", &[Value::I32(-1 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c134_l230_assert_trap() { + let mut instance = create_module_2(); + let result = c134_l230_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 231 +fn c135_l231_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c135_l231_action_invoke"); + let result = instance.call("i32.load16_s", &[Value::I32(65536 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c135_l231_assert_trap() { + let mut instance = create_module_2(); + let result = c135_l231_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 232 +fn c136_l232_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c136_l232_action_invoke"); + let result = instance.call("i32.load16_s", &[Value::I32(65535 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c136_l232_assert_trap() { + let mut instance = create_module_2(); + let result = c136_l232_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 233 +fn c137_l233_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c137_l233_action_invoke"); + let result = instance.call("i32.load16_s", &[Value::I32(-1 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c137_l233_assert_trap() { + let mut instance = create_module_2(); + let result = c137_l233_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 234 +fn c138_l234_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c138_l234_action_invoke"); + let result = instance.call("i32.load16_s", &[Value::I32(-2 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c138_l234_assert_trap() { + let mut instance = create_module_2(); + let result = c138_l234_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 235 +fn c139_l235_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c139_l235_action_invoke"); + let result = instance.call("i32.load16_u", &[Value::I32(65536 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c139_l235_assert_trap() { + let mut instance = create_module_2(); + let result = c139_l235_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 236 +fn c140_l236_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c140_l236_action_invoke"); + let result = instance.call("i32.load16_u", &[Value::I32(65535 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c140_l236_assert_trap() { + let mut instance = create_module_2(); + let result = c140_l236_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 237 +fn c141_l237_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c141_l237_action_invoke"); + let result = instance.call("i32.load16_u", &[Value::I32(-1 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c141_l237_assert_trap() { + let mut instance = create_module_2(); + let result = c141_l237_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 238 +fn c142_l238_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c142_l238_action_invoke"); + let result = instance.call("i32.load16_u", &[Value::I32(-2 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c142_l238_assert_trap() { + let mut instance = create_module_2(); + let result = c142_l238_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 239 +fn c143_l239_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c143_l239_action_invoke"); + let result = instance.call("i64.load8_s", &[Value::I32(65536 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c143_l239_assert_trap() { + let mut instance = create_module_2(); + let result = c143_l239_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 240 +fn c144_l240_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c144_l240_action_invoke"); + let result = instance.call("i64.load8_s", &[Value::I32(-1 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c144_l240_assert_trap() { + let mut instance = create_module_2(); + let result = c144_l240_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 241 +fn c145_l241_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c145_l241_action_invoke"); + let result = instance.call("i64.load8_u", &[Value::I32(65536 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c145_l241_assert_trap() { + let mut instance = create_module_2(); + let result = c145_l241_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 242 +fn c146_l242_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c146_l242_action_invoke"); + let result = instance.call("i64.load8_u", &[Value::I32(-1 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c146_l242_assert_trap() { + let mut instance = create_module_2(); + let result = c146_l242_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 243 +fn c147_l243_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c147_l243_action_invoke"); + let result = instance.call("i64.load16_s", &[Value::I32(65536 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c147_l243_assert_trap() { + let mut instance = create_module_2(); + let result = c147_l243_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 244 +fn c148_l244_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c148_l244_action_invoke"); + let result = instance.call("i64.load16_s", &[Value::I32(65535 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c148_l244_assert_trap() { + let mut instance = create_module_2(); + let result = c148_l244_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 245 +fn c149_l245_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c149_l245_action_invoke"); + let result = instance.call("i64.load16_s", &[Value::I32(-1 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c149_l245_assert_trap() { + let mut instance = create_module_2(); + let result = c149_l245_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 246 +fn c150_l246_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c150_l246_action_invoke"); + let result = instance.call("i64.load16_s", &[Value::I32(-2 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c150_l246_assert_trap() { + let mut instance = create_module_2(); + let result = c150_l246_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 247 +fn c151_l247_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c151_l247_action_invoke"); + let result = instance.call("i64.load16_u", &[Value::I32(65536 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c151_l247_assert_trap() { + let mut instance = create_module_2(); + let result = c151_l247_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 248 +fn c152_l248_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c152_l248_action_invoke"); + let result = instance.call("i64.load16_u", &[Value::I32(65535 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c152_l248_assert_trap() { + let mut instance = create_module_2(); + let result = c152_l248_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 249 +fn c153_l249_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c153_l249_action_invoke"); + let result = instance.call("i64.load16_u", &[Value::I32(-1 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c153_l249_assert_trap() { + let mut instance = create_module_2(); + let result = c153_l249_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 250 +fn c154_l250_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c154_l250_action_invoke"); + let result = instance.call("i64.load16_u", &[Value::I32(-2 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c154_l250_assert_trap() { + let mut instance = create_module_2(); + let result = c154_l250_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 251 +fn c155_l251_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c155_l251_action_invoke"); + let result = instance.call("i64.load32_s", &[Value::I32(65536 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c155_l251_assert_trap() { + let mut instance = create_module_2(); + let result = c155_l251_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 252 +fn c156_l252_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c156_l252_action_invoke"); + let result = instance.call("i64.load32_s", &[Value::I32(65535 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c156_l252_assert_trap() { + let mut instance = create_module_2(); + let result = c156_l252_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 253 +fn c157_l253_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c157_l253_action_invoke"); + let result = instance.call("i64.load32_s", &[Value::I32(65534 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c157_l253_assert_trap() { + let mut instance = create_module_2(); + let result = c157_l253_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 254 +fn c158_l254_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c158_l254_action_invoke"); + let result = instance.call("i64.load32_s", &[Value::I32(65533 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c158_l254_assert_trap() { + let mut instance = create_module_2(); + let result = c158_l254_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 255 +fn c159_l255_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c159_l255_action_invoke"); + let result = instance.call("i64.load32_s", &[Value::I32(-1 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c159_l255_assert_trap() { + let mut instance = create_module_2(); + let result = c159_l255_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 256 +fn c160_l256_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c160_l256_action_invoke"); + let result = instance.call("i64.load32_s", &[Value::I32(-2 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c160_l256_assert_trap() { + let mut instance = create_module_2(); + let result = c160_l256_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 257 +fn c161_l257_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c161_l257_action_invoke"); + let result = instance.call("i64.load32_s", &[Value::I32(-3 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c161_l257_assert_trap() { + let mut instance = create_module_2(); + let result = c161_l257_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 258 +fn c162_l258_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c162_l258_action_invoke"); + let result = instance.call("i64.load32_s", &[Value::I32(-4 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c162_l258_assert_trap() { + let mut instance = create_module_2(); + let result = c162_l258_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 259 +fn c163_l259_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c163_l259_action_invoke"); + let result = instance.call("i64.load32_u", &[Value::I32(65536 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c163_l259_assert_trap() { + let mut instance = create_module_2(); + let result = c163_l259_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 260 +fn c164_l260_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c164_l260_action_invoke"); + let result = instance.call("i64.load32_u", &[Value::I32(65535 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c164_l260_assert_trap() { + let mut instance = create_module_2(); + let result = c164_l260_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 261 +fn c165_l261_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c165_l261_action_invoke"); + let result = instance.call("i64.load32_u", &[Value::I32(65534 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c165_l261_assert_trap() { + let mut instance = create_module_2(); + let result = c165_l261_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 262 +fn c166_l262_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c166_l262_action_invoke"); + let result = instance.call("i64.load32_u", &[Value::I32(65533 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c166_l262_assert_trap() { + let mut instance = create_module_2(); + let result = c166_l262_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 263 +fn c167_l263_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c167_l263_action_invoke"); + let result = instance.call("i64.load32_u", &[Value::I32(-1 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c167_l263_assert_trap() { + let mut instance = create_module_2(); + let result = c167_l263_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 264 +fn c168_l264_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c168_l264_action_invoke"); + let result = instance.call("i64.load32_u", &[Value::I32(-2 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c168_l264_assert_trap() { + let mut instance = create_module_2(); + let result = c168_l264_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 265 +fn c169_l265_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c169_l265_action_invoke"); + let result = instance.call("i64.load32_u", &[Value::I32(-3 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c169_l265_assert_trap() { + let mut instance = create_module_2(); + let result = c169_l265_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 266 +fn c170_l266_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c170_l266_action_invoke"); + let result = instance.call("i64.load32_u", &[Value::I32(-4 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c170_l266_assert_trap() { + let mut instance = create_module_2(); + let result = c170_l266_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 269 +fn c171_l269_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c171_l269_action_invoke"); + let result = instance.call("i64.load", &[Value::I32(65528 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(7523094288207667809 as i64)))); + result.map(|_| ()) +} + +// Line 270 +fn c172_l270_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c172_l270_action_invoke"); + let result = instance.call("i64.load", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(7523094288207667809 as i64)))); + result.map(|_| ()) +} + +#[test] +fn test_module_2() { + let mut instance = create_module_2(); + // We group the calls together + start_module_2(&mut instance); + c171_l269_action_invoke(&mut instance); + c172_l270_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/mod.rs b/lib/runtime/tests/spectests/mod.rs new file mode 100644 index 000000000..e390ead73 --- /dev/null +++ b/lib/runtime/tests/spectests/mod.rs @@ -0,0 +1,77 @@ +// 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. + +// The _common module is not autogenerated, as it provides common functions for the spectests +mod _common; +#[cfg(not(feature = "fast-tests"))] +mod address; +mod align; +mod binary; +mod block; +mod br; +mod br_if; +mod br_table; +mod break_drop; +mod call; +mod call_indirect; +mod comments; +mod const_; +#[cfg(not(feature = "fast-tests"))] +mod conversions; +mod custom; +mod data; +mod elem; +mod endianness; +mod exports; +#[cfg(not(feature = "fast-tests"))] +mod f32_; +#[cfg(not(feature = "fast-tests"))] +mod f32_bitwise; +#[cfg(not(feature = "fast-tests"))] +mod f32_cmp; +#[cfg(not(feature = "fast-tests"))] +mod f64_; +#[cfg(not(feature = "fast-tests"))] +mod f64_bitwise; +#[cfg(not(feature = "fast-tests"))] +mod f64_cmp; +mod fac; +#[cfg(not(feature = "fast-tests"))] +mod float_exprs; +mod float_literals; +mod float_memory; +#[cfg(not(feature = "fast-tests"))] +mod float_misc; +mod forward; +mod func; +mod func_ptrs; +mod get_local; +mod globals; +#[cfg(not(feature = "fast-tests"))] +mod i32_; +#[cfg(not(feature = "fast-tests"))] +mod i64_; +mod if_; +mod int_exprs; +mod int_literals; +mod labels; +mod left_to_right; +mod loop_; +mod memory; +mod memory_grow; +mod memory_redundancy; +mod memory_trap; +mod nop; +mod return_; +mod select; +mod set_local; +mod stack; +mod start; +mod store_retval; +mod switch; +mod tee_local; +mod token; +mod traps; +mod typecheck; +mod types; +mod unwind; diff --git a/lib/runtime/tests/spectests/nop.rs b/lib/runtime/tests/spectests/nop.rs new file mode 100644 index 000000000..0d00b7eef --- /dev/null +++ b/lib/runtime/tests/spectests/nop.rs @@ -0,0 +1,1434 @@ +// 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/nop.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 3 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func (param i32 i32) (result i32))) + (type (;1;) (func)) + (type (;2;) (func (param i32 i32 i32) (result i32))) + (type (;3;) (func (result i32))) + (type (;4;) (func (param i32))) + (type (;5;) (func (param i32) (result i32))) + (type (;6;) (func (param i32 i32))) + (func (;0;) (type 1)) + (func (;1;) (type 2) (param i32 i32 i32) (result i32) + get_local 0 + get_local 1 + get_local 2 + i32.sub + i32.add) + (func (;2;) (type 3) (result i32) + nop + i32.const 1) + (func (;3;) (type 3) (result i32) + call 0 + nop + i32.const 2) + (func (;4;) (type 3) (result i32) + call 0 + i32.const 3 + nop) + (func (;5;) (type 3) (result i32) + nop + nop + call 0 + nop + i32.const 4 + nop + nop) + (func (;6;) (type 4) (param i32) + nop + get_local 0 + drop) + (func (;7;) (type 4) (param i32) + get_local 0 + nop + drop) + (func (;8;) (type 4) (param i32) + nop + nop + get_local 0 + nop + nop + drop) + (func (;9;) (type 5) (param i32) (result i32) + nop + get_local 0 + get_local 0 + get_local 0 + select) + (func (;10;) (type 5) (param i32) (result i32) + get_local 0 + nop + get_local 0 + get_local 0 + select) + (func (;11;) (type 5) (param i32) (result i32) + get_local 0 + get_local 0 + nop + get_local 0 + select) + (func (;12;) (type 5) (param i32) (result i32) + get_local 0 + get_local 0 + get_local 0 + nop + select) + (func (;13;) (type 5) (param i32) (result i32) + nop + get_local 0 + nop + nop + get_local 0 + nop + nop + get_local 0 + nop + nop + select) + (func (;14;) (type 3) (result i32) + block (result i32) ;; label = @1 + nop + i32.const 2 + end) + (func (;15;) (type 3) (result i32) + block (result i32) ;; label = @1 + call 0 + nop + i32.const 2 + end) + (func (;16;) (type 3) (result i32) + block (result i32) ;; label = @1 + nop + call 0 + i32.const 3 + nop + end) + (func (;17;) (type 3) (result i32) + block (result i32) ;; label = @1 + nop + nop + call 0 + nop + i32.const 4 + nop + nop + end) + (func (;18;) (type 3) (result i32) + loop (result i32) ;; label = @1 + nop + i32.const 2 + end) + (func (;19;) (type 3) (result i32) + loop (result i32) ;; label = @1 + call 0 + nop + i32.const 2 + end) + (func (;20;) (type 3) (result i32) + loop (result i32) ;; label = @1 + call 0 + i32.const 3 + nop + end) + (func (;21;) (type 3) (result i32) + loop (result i32) ;; label = @1 + nop + nop + call 0 + nop + i32.const 4 + nop + nop + end) + (func (;22;) (type 4) (param i32) + get_local 0 + nop + if ;; label = @1 + call 0 + end) + (func (;23;) (type 4) (param i32) + get_local 0 + if ;; label = @1 + nop + else + call 0 + end) + (func (;24;) (type 4) (param i32) + get_local 0 + if ;; label = @1 + call 0 + else + nop + end) + (func (;25;) (type 5) (param i32) (result i32) + block (result i32) ;; label = @1 + nop + get_local 0 + br 0 (;@1;) + end) + (func (;26;) (type 5) (param i32) (result i32) + block (result i32) ;; label = @1 + get_local 0 + nop + br 0 (;@1;) + end) + (func (;27;) (type 5) (param i32) (result i32) + block (result i32) ;; label = @1 + nop + nop + get_local 0 + nop + nop + br 0 (;@1;) + end) + (func (;28;) (type 5) (param i32) (result i32) + block (result i32) ;; label = @1 + nop + get_local 0 + get_local 0 + br_if 0 (;@1;) + end) + (func (;29;) (type 5) (param i32) (result i32) + block (result i32) ;; label = @1 + get_local 0 + nop + get_local 0 + br_if 0 (;@1;) + end) + (func (;30;) (type 5) (param i32) (result i32) + block (result i32) ;; label = @1 + get_local 0 + get_local 0 + nop + br_if 0 (;@1;) + end) + (func (;31;) (type 5) (param i32) (result i32) + block (result i32) ;; label = @1 + nop + nop + get_local 0 + nop + nop + get_local 0 + nop + nop + br_if 0 (;@1;) + end) + (func (;32;) (type 5) (param i32) (result i32) + block (result i32) ;; label = @1 + nop + get_local 0 + get_local 0 + br_table 0 (;@1;) 0 (;@1;) + end) + (func (;33;) (type 5) (param i32) (result i32) + block (result i32) ;; label = @1 + get_local 0 + nop + get_local 0 + br_table 0 (;@1;) 0 (;@1;) + end) + (func (;34;) (type 5) (param i32) (result i32) + block (result i32) ;; label = @1 + get_local 0 + get_local 0 + nop + br_table 0 (;@1;) 0 (;@1;) + end) + (func (;35;) (type 5) (param i32) (result i32) + block (result i32) ;; label = @1 + nop + nop + get_local 0 + nop + nop + get_local 0 + nop + nop + br_table 0 (;@1;) 0 (;@1;) + end) + (func (;36;) (type 5) (param i32) (result i32) + nop + get_local 0 + return) + (func (;37;) (type 5) (param i32) (result i32) + get_local 0 + nop + return) + (func (;38;) (type 5) (param i32) (result i32) + nop + nop + get_local 0 + nop + nop + return) + (func (;39;) (type 2) (param i32 i32 i32) (result i32) + nop + get_local 0 + get_local 1 + get_local 2 + call 1) + (func (;40;) (type 2) (param i32 i32 i32) (result i32) + get_local 0 + nop + get_local 1 + get_local 2 + call 1) + (func (;41;) (type 2) (param i32 i32 i32) (result i32) + get_local 0 + get_local 1 + nop + get_local 2 + call 1) + (func (;42;) (type 2) (param i32 i32 i32) (result i32) + get_local 0 + get_local 1 + get_local 2 + nop + call 1) + (func (;43;) (type 2) (param i32 i32 i32) (result i32) + nop + nop + get_local 0 + nop + nop + get_local 1 + nop + nop + get_local 2 + nop + nop + call 1) + (func (;44;) (type 5) (param i32) (result i32) + nop + get_local 0 + i32.ctz) + (func (;45;) (type 5) (param i32) (result i32) + get_local 0 + nop + i32.ctz) + (func (;46;) (type 5) (param i32) (result i32) + nop + nop + get_local 0 + nop + nop + i32.ctz) + (func (;47;) (type 5) (param i32) (result i32) + nop + get_local 0 + get_local 0 + i32.add) + (func (;48;) (type 5) (param i32) (result i32) + get_local 0 + nop + get_local 0 + i32.add) + (func (;49;) (type 5) (param i32) (result i32) + get_local 0 + get_local 0 + nop + i32.add) + (func (;50;) (type 5) (param i32) (result i32) + nop + get_local 0 + nop + nop + get_local 0 + nop + nop + i32.add) + (func (;51;) (type 5) (param i32) (result i32) + nop + get_local 0 + i32.eqz) + (func (;52;) (type 5) (param i32) (result i32) + get_local 0 + nop + i32.eqz) + (func (;53;) (type 5) (param i32) (result i32) + nop + nop + get_local 0 + nop + nop + i32.eqz) + (func (;54;) (type 5) (param i32) (result i32) + nop + get_local 0 + get_local 0 + i32.ne) + (func (;55;) (type 5) (param i32) (result i32) + get_local 0 + nop + get_local 0 + i32.ne) + (func (;56;) (type 5) (param i32) (result i32) + get_local 0 + get_local 0 + nop + i32.lt_u) + (func (;57;) (type 5) (param i32) (result i32) + nop + get_local 0 + nop + nop + get_local 0 + nop + nop + i32.le_s) + (func (;58;) (type 5) (param i32) (result i32) + nop + get_local 0 + memory.grow) + (func (;59;) (type 5) (param i32) (result i32) + get_local 0 + nop + memory.grow) + (func (;60;) (type 5) (param i32) (result i32) + nop + nop + get_local 0 + nop + nop + memory.grow) + (func (;61;) (type 0) (param i32 i32) (result i32) + get_local 0) + (func (;62;) (type 3) (result i32) + block (result i32) ;; label = @1 + nop + i32.const 1 + i32.const 2 + i32.const 0 + call_indirect (type 0) + end) + (func (;63;) (type 3) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + nop + i32.const 2 + i32.const 0 + call_indirect (type 0) + end) + (func (;64;) (type 3) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + i32.const 2 + nop + i32.const 0 + call_indirect (type 0) + end) + (func (;65;) (type 3) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + i32.const 2 + i32.const 0 + nop + call_indirect (type 0) + end) + (func (;66;) (type 3) (result i32) + block (result i32) ;; label = @1 + nop + nop + i32.const 1 + nop + nop + i32.const 2 + nop + nop + i32.const 0 + nop + nop + call_indirect (type 0) + end) + (func (;67;) (type 5) (param i32) (result i32) + nop + i32.const 2 + set_local 0 + get_local 0) + (func (;68;) (type 5) (param i32) (result i32) + i32.const 2 + nop + set_local 0 + get_local 0) + (func (;69;) (type 5) (param i32) (result i32) + nop + nop + i32.const 2 + nop + nop + set_local 0 + get_local 0) + (func (;70;) (type 5) (param i32) (result i32) + nop + i32.const 2 + tee_local 0) + (func (;71;) (type 5) (param i32) (result i32) + i32.const 2 + nop + tee_local 0) + (func (;72;) (type 5) (param i32) (result i32) + nop + nop + i32.const 2 + nop + nop + tee_local 0) + (func (;73;) (type 3) (result i32) + nop + i32.const 2 + set_global 0 + get_global 0) + (func (;74;) (type 3) (result i32) + i32.const 2 + nop + set_global 0 + get_global 0) + (func (;75;) (type 3) (result i32) + nop + nop + i32.const 2 + nop + nop + set_global 0 + get_global 0) + (func (;76;) (type 5) (param i32) (result i32) + nop + get_local 0 + i32.load) + (func (;77;) (type 5) (param i32) (result i32) + get_local 0 + nop + i32.load) + (func (;78;) (type 5) (param i32) (result i32) + nop + nop + get_local 0 + nop + nop + i32.load) + (func (;79;) (type 6) (param i32 i32) + nop + get_local 0 + get_local 1 + i32.store) + (func (;80;) (type 6) (param i32 i32) + get_local 0 + nop + get_local 1 + i32.store) + (func (;81;) (type 6) (param i32 i32) + get_local 0 + get_local 1 + nop + i32.store) + (func (;82;) (type 6) (param i32 i32) + nop + nop + get_local 0 + nop + nop + get_local 1 + nop + nop + i32.store) + (table (;0;) 1 1 anyfunc) + (memory (;0;) 1) + (global (;0;) (mut i32) (i32.const 0)) + (export \"as-func-first\" (func 2)) + (export \"as-func-mid\" (func 3)) + (export \"as-func-last\" (func 4)) + (export \"as-func-everywhere\" (func 5)) + (export \"as-drop-first\" (func 6)) + (export \"as-drop-last\" (func 7)) + (export \"as-drop-everywhere\" (func 8)) + (export \"as-select-first\" (func 9)) + (export \"as-select-mid1\" (func 10)) + (export \"as-select-mid2\" (func 11)) + (export \"as-select-last\" (func 12)) + (export \"as-select-everywhere\" (func 13)) + (export \"as-block-first\" (func 14)) + (export \"as-block-mid\" (func 15)) + (export \"as-block-last\" (func 16)) + (export \"as-block-everywhere\" (func 17)) + (export \"as-loop-first\" (func 18)) + (export \"as-loop-mid\" (func 19)) + (export \"as-loop-last\" (func 20)) + (export \"as-loop-everywhere\" (func 21)) + (export \"as-if-condition\" (func 22)) + (export \"as-if-then\" (func 23)) + (export \"as-if-else\" (func 24)) + (export \"as-br-first\" (func 25)) + (export \"as-br-last\" (func 26)) + (export \"as-br-everywhere\" (func 27)) + (export \"as-br_if-first\" (func 28)) + (export \"as-br_if-mid\" (func 29)) + (export \"as-br_if-last\" (func 30)) + (export \"as-br_if-everywhere\" (func 31)) + (export \"as-br_table-first\" (func 32)) + (export \"as-br_table-mid\" (func 33)) + (export \"as-br_table-last\" (func 34)) + (export \"as-br_table-everywhere\" (func 35)) + (export \"as-return-first\" (func 36)) + (export \"as-return-last\" (func 37)) + (export \"as-return-everywhere\" (func 38)) + (export \"as-call-first\" (func 39)) + (export \"as-call-mid1\" (func 40)) + (export \"as-call-mid2\" (func 41)) + (export \"as-call-last\" (func 42)) + (export \"as-call-everywhere\" (func 43)) + (export \"as-unary-first\" (func 44)) + (export \"as-unary-last\" (func 45)) + (export \"as-unary-everywhere\" (func 46)) + (export \"as-binary-first\" (func 47)) + (export \"as-binary-mid\" (func 48)) + (export \"as-binary-last\" (func 49)) + (export \"as-binary-everywhere\" (func 50)) + (export \"as-test-first\" (func 51)) + (export \"as-test-last\" (func 52)) + (export \"as-test-everywhere\" (func 53)) + (export \"as-compare-first\" (func 54)) + (export \"as-compare-mid\" (func 55)) + (export \"as-compare-last\" (func 56)) + (export \"as-compare-everywhere\" (func 57)) + (export \"as-memory.grow-first\" (func 58)) + (export \"as-memory.grow-last\" (func 59)) + (export \"as-memory.grow-everywhere\" (func 60)) + (export \"as-call_indirect-first\" (func 62)) + (export \"as-call_indirect-mid1\" (func 63)) + (export \"as-call_indirect-mid2\" (func 64)) + (export \"as-call_indirect-last\" (func 65)) + (export \"as-call_indirect-everywhere\" (func 66)) + (export \"as-set_local-first\" (func 67)) + (export \"as-set_local-last\" (func 68)) + (export \"as-set_local-everywhere\" (func 69)) + (export \"as-tee_local-first\" (func 70)) + (export \"as-tee_local-last\" (func 71)) + (export \"as-tee_local-everywhere\" (func 72)) + (export \"as-set_global-first\" (func 73)) + (export \"as-set_global-last\" (func 74)) + (export \"as-set_global-everywhere\" (func 75)) + (export \"as-load-first\" (func 76)) + (export \"as-load-last\" (func 77)) + (export \"as-load-everywhere\" (func 78)) + (export \"as-store-first\" (func 79)) + (export \"as-store-mid\" (func 80)) + (export \"as-store-last\" (func 81)) + (export \"as-store-everywhere\" (func 82)) + (elem (;0;) (i32.const 0) 61)) + "; + 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 306 +fn c1_l306_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l306_action_invoke"); + let result = instance.call("as-func-first", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 307 +fn c2_l307_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l307_action_invoke"); + let result = instance.call("as-func-mid", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 308 +fn c3_l308_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l308_action_invoke"); + let result = instance.call("as-func-last", &[]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 309 +fn c4_l309_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l309_action_invoke"); + let result = instance.call("as-func-everywhere", &[]); + assert_eq!(result, Ok(Some(Value::I32(4 as i32)))); + result.map(|_| ()) +} + +// Line 311 +fn c5_l311_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l311_action_invoke"); + let result = instance.call("as-drop-first", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 312 +fn c6_l312_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l312_action_invoke"); + let result = instance.call("as-drop-last", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 313 +fn c7_l313_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l313_action_invoke"); + let result = instance.call("as-drop-everywhere", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 315 +fn c8_l315_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l315_action_invoke"); + let result = instance.call("as-select-first", &[Value::I32(3 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 316 +fn c9_l316_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l316_action_invoke"); + let result = instance.call("as-select-mid1", &[Value::I32(3 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 317 +fn c10_l317_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c10_l317_action_invoke"); + let result = instance.call("as-select-mid2", &[Value::I32(3 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 318 +fn c11_l318_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c11_l318_action_invoke"); + let result = instance.call("as-select-last", &[Value::I32(3 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 319 +fn c12_l319_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c12_l319_action_invoke"); + let result = instance.call("as-select-everywhere", &[Value::I32(3 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 321 +fn c13_l321_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c13_l321_action_invoke"); + let result = instance.call("as-block-first", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 322 +fn c14_l322_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c14_l322_action_invoke"); + let result = instance.call("as-block-mid", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 323 +fn c15_l323_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c15_l323_action_invoke"); + let result = instance.call("as-block-last", &[]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 324 +fn c16_l324_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c16_l324_action_invoke"); + let result = instance.call("as-block-everywhere", &[]); + assert_eq!(result, Ok(Some(Value::I32(4 as i32)))); + result.map(|_| ()) +} + +// Line 326 +fn c17_l326_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c17_l326_action_invoke"); + let result = instance.call("as-loop-first", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 327 +fn c18_l327_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c18_l327_action_invoke"); + let result = instance.call("as-loop-mid", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 328 +fn c19_l328_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c19_l328_action_invoke"); + let result = instance.call("as-loop-last", &[]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 329 +fn c20_l329_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c20_l329_action_invoke"); + let result = instance.call("as-loop-everywhere", &[]); + assert_eq!(result, Ok(Some(Value::I32(4 as i32)))); + result.map(|_| ()) +} + +// Line 331 +fn c21_l331_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c21_l331_action_invoke"); + let result = instance.call("as-if-condition", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 332 +fn c22_l332_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c22_l332_action_invoke"); + let result = instance.call("as-if-condition", &[Value::I32(-1 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 333 +fn c23_l333_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c23_l333_action_invoke"); + let result = instance.call("as-if-then", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 334 +fn c24_l334_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c24_l334_action_invoke"); + let result = instance.call("as-if-then", &[Value::I32(4 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 335 +fn c25_l335_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c25_l335_action_invoke"); + let result = instance.call("as-if-else", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 336 +fn c26_l336_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c26_l336_action_invoke"); + let result = instance.call("as-if-else", &[Value::I32(3 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 338 +fn c27_l338_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c27_l338_action_invoke"); + let result = instance.call("as-br-first", &[Value::I32(5 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(5 as i32)))); + result.map(|_| ()) +} + +// Line 339 +fn c28_l339_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c28_l339_action_invoke"); + let result = instance.call("as-br-last", &[Value::I32(6 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); + result.map(|_| ()) +} + +// Line 340 +fn c29_l340_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c29_l340_action_invoke"); + let result = instance.call("as-br-everywhere", &[Value::I32(7 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(7 as i32)))); + result.map(|_| ()) +} + +// Line 342 +fn c30_l342_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c30_l342_action_invoke"); + let result = instance.call("as-br_if-first", &[Value::I32(4 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(4 as i32)))); + result.map(|_| ()) +} + +// Line 343 +fn c31_l343_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c31_l343_action_invoke"); + let result = instance.call("as-br_if-mid", &[Value::I32(5 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(5 as i32)))); + result.map(|_| ()) +} + +// Line 344 +fn c32_l344_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c32_l344_action_invoke"); + let result = instance.call("as-br_if-last", &[Value::I32(6 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); + result.map(|_| ()) +} + +// Line 345 +fn c33_l345_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c33_l345_action_invoke"); + let result = instance.call("as-br_if-everywhere", &[Value::I32(7 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(7 as i32)))); + result.map(|_| ()) +} + +// Line 347 +fn c34_l347_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c34_l347_action_invoke"); + let result = instance.call("as-br_table-first", &[Value::I32(4 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(4 as i32)))); + result.map(|_| ()) +} + +// Line 348 +fn c35_l348_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c35_l348_action_invoke"); + let result = instance.call("as-br_table-mid", &[Value::I32(5 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(5 as i32)))); + result.map(|_| ()) +} + +// Line 349 +fn c36_l349_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c36_l349_action_invoke"); + let result = instance.call("as-br_table-last", &[Value::I32(6 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); + result.map(|_| ()) +} + +// Line 350 +fn c37_l350_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c37_l350_action_invoke"); + let result = instance.call("as-br_table-everywhere", &[Value::I32(7 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(7 as i32)))); + result.map(|_| ()) +} + +// Line 352 +fn c38_l352_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c38_l352_action_invoke"); + let result = instance.call("as-return-first", &[Value::I32(5 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(5 as i32)))); + result.map(|_| ()) +} + +// Line 353 +fn c39_l353_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c39_l353_action_invoke"); + let result = instance.call("as-return-last", &[Value::I32(6 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); + result.map(|_| ()) +} + +// Line 354 +fn c40_l354_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c40_l354_action_invoke"); + let result = instance.call("as-return-everywhere", &[Value::I32(7 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(7 as i32)))); + result.map(|_| ()) +} + +// Line 356 +fn c41_l356_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c41_l356_action_invoke"); + let result = instance.call("as-call-first", &[Value::I32(3 as i32), Value::I32(1 as i32), Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 357 +fn c42_l357_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c42_l357_action_invoke"); + let result = instance.call("as-call-mid1", &[Value::I32(3 as i32), Value::I32(1 as i32), Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 358 +fn c43_l358_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c43_l358_action_invoke"); + let result = instance.call("as-call-mid2", &[Value::I32(0 as i32), Value::I32(3 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 359 +fn c44_l359_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c44_l359_action_invoke"); + let result = instance.call("as-call-last", &[Value::I32(10 as i32), Value::I32(9 as i32), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(20 as i32)))); + result.map(|_| ()) +} + +// Line 360 +fn c45_l360_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c45_l360_action_invoke"); + let result = instance.call("as-call-everywhere", &[Value::I32(2 as i32), Value::I32(1 as i32), Value::I32(5 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-2 as i32)))); + result.map(|_| ()) +} + +// Line 362 +fn c46_l362_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c46_l362_action_invoke"); + let result = instance.call("as-unary-first", &[Value::I32(30 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 363 +fn c47_l363_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c47_l363_action_invoke"); + let result = instance.call("as-unary-last", &[Value::I32(30 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 364 +fn c48_l364_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c48_l364_action_invoke"); + let result = instance.call("as-unary-everywhere", &[Value::I32(12 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 366 +fn c49_l366_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c49_l366_action_invoke"); + let result = instance.call("as-binary-first", &[Value::I32(3 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); + result.map(|_| ()) +} + +// Line 367 +fn c50_l367_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c50_l367_action_invoke"); + let result = instance.call("as-binary-mid", &[Value::I32(3 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); + result.map(|_| ()) +} + +// Line 368 +fn c51_l368_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c51_l368_action_invoke"); + let result = instance.call("as-binary-last", &[Value::I32(3 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); + result.map(|_| ()) +} + +// Line 369 +fn c52_l369_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c52_l369_action_invoke"); + let result = instance.call("as-binary-everywhere", &[Value::I32(3 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); + result.map(|_| ()) +} + +// Line 371 +fn c53_l371_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c53_l371_action_invoke"); + let result = instance.call("as-test-first", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 372 +fn c54_l372_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c54_l372_action_invoke"); + let result = instance.call("as-test-last", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 373 +fn c55_l373_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c55_l373_action_invoke"); + let result = instance.call("as-test-everywhere", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 375 +fn c56_l375_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c56_l375_action_invoke"); + let result = instance.call("as-compare-first", &[Value::I32(3 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 376 +fn c57_l376_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c57_l376_action_invoke"); + let result = instance.call("as-compare-mid", &[Value::I32(3 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 377 +fn c58_l377_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c58_l377_action_invoke"); + let result = instance.call("as-compare-last", &[Value::I32(3 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 378 +fn c59_l378_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c59_l378_action_invoke"); + let result = instance.call("as-compare-everywhere", &[Value::I32(3 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 380 +fn c60_l380_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c60_l380_action_invoke"); + let result = instance.call("as-memory.grow-first", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 381 +fn c61_l381_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c61_l381_action_invoke"); + let result = instance.call("as-memory.grow-last", &[Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 382 +fn c62_l382_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c62_l382_action_invoke"); + let result = instance.call("as-memory.grow-everywhere", &[Value::I32(12 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 384 +fn c63_l384_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c63_l384_action_invoke"); + let result = instance.call("as-call_indirect-first", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 385 +fn c64_l385_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c64_l385_action_invoke"); + let result = instance.call("as-call_indirect-mid1", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 386 +fn c65_l386_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c65_l386_action_invoke"); + let result = instance.call("as-call_indirect-mid2", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 387 +fn c66_l387_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c66_l387_action_invoke"); + let result = instance.call("as-call_indirect-last", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 388 +fn c67_l388_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c67_l388_action_invoke"); + let result = instance.call("as-call_indirect-everywhere", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 390 +fn c68_l390_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c68_l390_action_invoke"); + let result = instance.call("as-set_local-first", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 391 +fn c69_l391_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c69_l391_action_invoke"); + let result = instance.call("as-set_local-last", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 392 +fn c70_l392_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c70_l392_action_invoke"); + let result = instance.call("as-set_local-everywhere", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 394 +fn c71_l394_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c71_l394_action_invoke"); + let result = instance.call("as-tee_local-first", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 395 +fn c72_l395_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c72_l395_action_invoke"); + let result = instance.call("as-tee_local-last", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 396 +fn c73_l396_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c73_l396_action_invoke"); + let result = instance.call("as-tee_local-everywhere", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 398 +fn c74_l398_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c74_l398_action_invoke"); + let result = instance.call("as-set_global-first", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 399 +fn c75_l399_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c75_l399_action_invoke"); + let result = instance.call("as-set_global-last", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 400 +fn c76_l400_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c76_l400_action_invoke"); + let result = instance.call("as-set_global-everywhere", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 402 +fn c77_l402_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c77_l402_action_invoke"); + let result = instance.call("as-load-first", &[Value::I32(100 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 403 +fn c78_l403_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c78_l403_action_invoke"); + let result = instance.call("as-load-last", &[Value::I32(100 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 404 +fn c79_l404_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c79_l404_action_invoke"); + let result = instance.call("as-load-everywhere", &[Value::I32(100 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 406 +fn c80_l406_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c80_l406_action_invoke"); + let result = instance.call("as-store-first", &[Value::I32(0 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 407 +fn c81_l407_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c81_l407_action_invoke"); + let result = instance.call("as-store-mid", &[Value::I32(0 as i32), Value::I32(2 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 408 +fn c82_l408_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c82_l408_action_invoke"); + let result = instance.call("as-store-last", &[Value::I32(0 as i32), Value::I32(3 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 409 +fn c83_l409_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c83_l409_action_invoke"); + let result = instance.call("as-store-everywhere", &[Value::I32(0 as i32), Value::I32(4 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 412 +#[test] +fn c84_l412_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 5, 1, 3, 0, 1, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 416 +#[test] +fn c85_l416_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 5, 1, 3, 0, 1, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 420 +#[test] +fn c86_l420_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 5, 1, 3, 0, 1, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 424 +#[test] +fn c87_l424_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 5, 1, 3, 0, 1, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l306_action_invoke(&mut instance); + c2_l307_action_invoke(&mut instance); + c3_l308_action_invoke(&mut instance); + c4_l309_action_invoke(&mut instance); + c5_l311_action_invoke(&mut instance); + c6_l312_action_invoke(&mut instance); + c7_l313_action_invoke(&mut instance); + c8_l315_action_invoke(&mut instance); + c9_l316_action_invoke(&mut instance); + c10_l317_action_invoke(&mut instance); + c11_l318_action_invoke(&mut instance); + c12_l319_action_invoke(&mut instance); + c13_l321_action_invoke(&mut instance); + c14_l322_action_invoke(&mut instance); + c15_l323_action_invoke(&mut instance); + c16_l324_action_invoke(&mut instance); + c17_l326_action_invoke(&mut instance); + c18_l327_action_invoke(&mut instance); + c19_l328_action_invoke(&mut instance); + c20_l329_action_invoke(&mut instance); + c21_l331_action_invoke(&mut instance); + c22_l332_action_invoke(&mut instance); + c23_l333_action_invoke(&mut instance); + c24_l334_action_invoke(&mut instance); + c25_l335_action_invoke(&mut instance); + c26_l336_action_invoke(&mut instance); + c27_l338_action_invoke(&mut instance); + c28_l339_action_invoke(&mut instance); + c29_l340_action_invoke(&mut instance); + c30_l342_action_invoke(&mut instance); + c31_l343_action_invoke(&mut instance); + c32_l344_action_invoke(&mut instance); + c33_l345_action_invoke(&mut instance); + c34_l347_action_invoke(&mut instance); + c35_l348_action_invoke(&mut instance); + c36_l349_action_invoke(&mut instance); + c37_l350_action_invoke(&mut instance); + c38_l352_action_invoke(&mut instance); + c39_l353_action_invoke(&mut instance); + c40_l354_action_invoke(&mut instance); + c41_l356_action_invoke(&mut instance); + c42_l357_action_invoke(&mut instance); + c43_l358_action_invoke(&mut instance); + c44_l359_action_invoke(&mut instance); + c45_l360_action_invoke(&mut instance); + c46_l362_action_invoke(&mut instance); + c47_l363_action_invoke(&mut instance); + c48_l364_action_invoke(&mut instance); + c49_l366_action_invoke(&mut instance); + c50_l367_action_invoke(&mut instance); + c51_l368_action_invoke(&mut instance); + c52_l369_action_invoke(&mut instance); + c53_l371_action_invoke(&mut instance); + c54_l372_action_invoke(&mut instance); + c55_l373_action_invoke(&mut instance); + c56_l375_action_invoke(&mut instance); + c57_l376_action_invoke(&mut instance); + c58_l377_action_invoke(&mut instance); + c59_l378_action_invoke(&mut instance); + c60_l380_action_invoke(&mut instance); + c61_l381_action_invoke(&mut instance); + c62_l382_action_invoke(&mut instance); + c63_l384_action_invoke(&mut instance); + c64_l385_action_invoke(&mut instance); + c65_l386_action_invoke(&mut instance); + c66_l387_action_invoke(&mut instance); + c67_l388_action_invoke(&mut instance); + c68_l390_action_invoke(&mut instance); + c69_l391_action_invoke(&mut instance); + c70_l392_action_invoke(&mut instance); + c71_l394_action_invoke(&mut instance); + c72_l395_action_invoke(&mut instance); + c73_l396_action_invoke(&mut instance); + c74_l398_action_invoke(&mut instance); + c75_l399_action_invoke(&mut instance); + c76_l400_action_invoke(&mut instance); + c77_l402_action_invoke(&mut instance); + c78_l403_action_invoke(&mut instance); + c79_l404_action_invoke(&mut instance); + c80_l406_action_invoke(&mut instance); + c81_l407_action_invoke(&mut instance); + c82_l408_action_invoke(&mut instance); + c83_l409_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/return_.rs b/lib/runtime/tests/spectests/return_.rs new file mode 100644 index 000000000..244e500e6 --- /dev/null +++ b/lib/runtime/tests/spectests/return_.rs @@ -0,0 +1,1008 @@ +// 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/return_.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 3 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func (param i32 i32 i32) (result i32))) + (type (;1;) (func)) + (type (;2;) (func (result i32))) + (type (;3;) (func (result i64))) + (type (;4;) (func (result f32))) + (type (;5;) (func (result f64))) + (type (;6;) (func (param i32 i32) (result i32))) + (func (;0;) (type 1)) + (func (;1;) (type 1) + return + i32.ctz + drop) + (func (;2;) (type 1) + return + i64.ctz + drop) + (func (;3;) (type 1) + return + f32.neg + drop) + (func (;4;) (type 1) + return + f64.neg + drop) + (func (;5;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + return + i32.ctz + end) + (func (;6;) (type 3) (result i64) + block (result i64) ;; label = @1 + i64.const 2 + return + i64.ctz + end) + (func (;7;) (type 4) (result f32) + block (result f32) ;; label = @1 + f32.const 0x1.8p+1 (;=3;) + return + f32.neg + end) + (func (;8;) (type 5) (result f64) + block (result f64) ;; label = @1 + f64.const 0x1p+2 (;=4;) + return + f64.neg + end) + (func (;9;) (type 1) + return) + (func (;10;) (type 5) (result f64) + f64.const 0x1.8p+1 (;=3;) + return) + (func (;11;) (type 2) (result i32) + i32.const 1 + return + i32.const 2) + (func (;12;) (type 2) (result i32) + call 0 + i32.const 2 + return + i32.const 3) + (func (;13;) (type 1) + nop + call 0 + return) + (func (;14;) (type 2) (result i32) + nop + call 0 + i32.const 3 + return) + (func (;15;) (type 1) + block ;; label = @1 + return + call 0 + end) + (func (;16;) (type 1) + block ;; label = @1 + call 0 + return + call 0 + end) + (func (;17;) (type 1) + block ;; label = @1 + nop + call 0 + return + end) + (func (;18;) (type 2) (result i32) + block (result i32) ;; label = @1 + nop + call 0 + i32.const 2 + return + end) + (func (;19;) (type 2) (result i32) + loop (result i32) ;; label = @1 + i32.const 3 + return + i32.const 2 + end) + (func (;20;) (type 2) (result i32) + loop (result i32) ;; label = @1 + call 0 + i32.const 4 + return + i32.const 2 + end) + (func (;21;) (type 2) (result i32) + loop (result i32) ;; label = @1 + nop + call 0 + i32.const 5 + return + end) + (func (;22;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 9 + return + br 0 (;@1;) + end) + (func (;23;) (type 1) + block ;; label = @1 + return + br_if 0 (;@1;) + end) + (func (;24;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 8 + return + i32.const 1 + br_if 0 (;@1;) + drop + i32.const 7 + end) + (func (;25;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 6 + i32.const 9 + return + br_if 0 (;@1;) + drop + i32.const 7 + end) + (func (;26;) (type 3) (result i64) + block ;; label = @1 + i64.const 9 + return + br_table 0 (;@1;) 0 (;@1;) 0 (;@1;) + end + i64.const -1) + (func (;27;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 10 + return + i32.const 1 + br_table 0 (;@1;) 0 (;@1;) 0 (;@1;) + i32.const 7 + end) + (func (;28;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 6 + i32.const 11 + return + br_table 0 (;@1;) 0 (;@1;) + i32.const 7 + end) + (func (;29;) (type 3) (result i64) + i64.const 7 + return + return) + (func (;30;) (type 2) (result i32) + i32.const 2 + return + if (result i32) ;; label = @1 + i32.const 0 + else + i32.const 1 + end) + (func (;31;) (type 6) (param i32 i32) (result i32) + get_local 0 + if (result i32) ;; label = @1 + i32.const 3 + return + else + get_local 1 + end) + (func (;32;) (type 6) (param i32 i32) (result i32) + get_local 0 + if (result i32) ;; label = @1 + get_local 1 + else + i32.const 4 + return + end) + (func (;33;) (type 6) (param i32 i32) (result i32) + i32.const 5 + return + get_local 0 + get_local 1 + select) + (func (;34;) (type 6) (param i32 i32) (result i32) + get_local 0 + i32.const 6 + return + get_local 1 + select) + (func (;35;) (type 2) (result i32) + i32.const 0 + i32.const 1 + i32.const 7 + return + select) + (func (;36;) (type 0) (param i32 i32 i32) (result i32) + i32.const -1) + (func (;37;) (type 2) (result i32) + i32.const 12 + return + i32.const 2 + i32.const 3 + call 36) + (func (;38;) (type 2) (result i32) + i32.const 1 + i32.const 13 + return + i32.const 3 + call 36) + (func (;39;) (type 2) (result i32) + i32.const 1 + i32.const 2 + i32.const 14 + return + call 36) + (func (;40;) (type 2) (result i32) + i32.const 20 + return + i32.const 1 + i32.const 2 + i32.const 3 + call_indirect (type 0)) + (func (;41;) (type 2) (result i32) + i32.const 0 + i32.const 21 + return + i32.const 2 + i32.const 3 + call_indirect (type 0)) + (func (;42;) (type 2) (result i32) + i32.const 0 + i32.const 1 + i32.const 22 + return + i32.const 3 + call_indirect (type 0)) + (func (;43;) (type 2) (result i32) + i32.const 0 + i32.const 1 + i32.const 2 + i32.const 23 + return + call_indirect (type 0)) + (func (;44;) (type 2) (result i32) + (local f32) + i32.const 17 + return + set_local 0 + i32.const -1) + (func (;45;) (type 4) (result f32) + f32.const 0x1.b33334p+0 (;=1.7;) + return + f32.load) + (func (;46;) (type 3) (result i64) + i64.const 30 + return + i64.load8_s) + (func (;47;) (type 2) (result i32) + i32.const 30 + return + f64.const 0x1.cp+2 (;=7;) + f64.store + i32.const -1) + (func (;48;) (type 2) (result i32) + i32.const 2 + i32.const 31 + return + i64.store + i32.const -1) + (func (;49;) (type 2) (result i32) + i32.const 32 + return + i32.const 7 + i32.store8 + i32.const -1) + (func (;50;) (type 2) (result i32) + i32.const 2 + i32.const 33 + return + i64.store16 + i32.const -1) + (func (;51;) (type 4) (result f32) + f32.const 0x1.b33334p+1 (;=3.4;) + return + f32.neg) + (func (;52;) (type 2) (result i32) + i32.const 3 + return + i32.const 10 + i32.add) + (func (;53;) (type 3) (result i64) + i64.const 10 + i64.const 45 + return + i64.sub) + (func (;54;) (type 2) (result i32) + i32.const 44 + return + i32.eqz) + (func (;55;) (type 2) (result i32) + i32.const 43 + return + f64.const 0x1.4p+3 (;=10;) + f64.le) + (func (;56;) (type 2) (result i32) + f32.const 0x1.4p+3 (;=10;) + i32.const 42 + return + f32.ne) + (func (;57;) (type 2) (result i32) + i32.const 41 + return + i32.wrap/i64) + (func (;58;) (type 2) (result i32) + i32.const 40 + return + memory.grow) + (table (;0;) 1 1 anyfunc) + (memory (;0;) 1) + (export \"type-i32\" (func 1)) + (export \"type-i64\" (func 2)) + (export \"type-f32\" (func 3)) + (export \"type-f64\" (func 4)) + (export \"type-i32-value\" (func 5)) + (export \"type-i64-value\" (func 6)) + (export \"type-f32-value\" (func 7)) + (export \"type-f64-value\" (func 8)) + (export \"nullary\" (func 9)) + (export \"unary\" (func 10)) + (export \"as-func-first\" (func 11)) + (export \"as-func-mid\" (func 12)) + (export \"as-func-last\" (func 13)) + (export \"as-func-value\" (func 14)) + (export \"as-block-first\" (func 15)) + (export \"as-block-mid\" (func 16)) + (export \"as-block-last\" (func 17)) + (export \"as-block-value\" (func 18)) + (export \"as-loop-first\" (func 19)) + (export \"as-loop-mid\" (func 20)) + (export \"as-loop-last\" (func 21)) + (export \"as-br-value\" (func 22)) + (export \"as-br_if-cond\" (func 23)) + (export \"as-br_if-value\" (func 24)) + (export \"as-br_if-value-cond\" (func 25)) + (export \"as-br_table-index\" (func 26)) + (export \"as-br_table-value\" (func 27)) + (export \"as-br_table-value-index\" (func 28)) + (export \"as-return-value\" (func 29)) + (export \"as-if-cond\" (func 30)) + (export \"as-if-then\" (func 31)) + (export \"as-if-else\" (func 32)) + (export \"as-select-first\" (func 33)) + (export \"as-select-second\" (func 34)) + (export \"as-select-cond\" (func 35)) + (export \"as-call-first\" (func 37)) + (export \"as-call-mid\" (func 38)) + (export \"as-call-last\" (func 39)) + (export \"as-call_indirect-func\" (func 40)) + (export \"as-call_indirect-first\" (func 41)) + (export \"as-call_indirect-mid\" (func 42)) + (export \"as-call_indirect-last\" (func 43)) + (export \"as-set_local-value\" (func 44)) + (export \"as-load-address\" (func 45)) + (export \"as-loadN-address\" (func 46)) + (export \"as-store-address\" (func 47)) + (export \"as-store-value\" (func 48)) + (export \"as-storeN-address\" (func 49)) + (export \"as-storeN-value\" (func 50)) + (export \"as-unary-operand\" (func 51)) + (export \"as-binary-left\" (func 52)) + (export \"as-binary-right\" (func 53)) + (export \"as-test-operand\" (func 54)) + (export \"as-compare-left\" (func 55)) + (export \"as-compare-right\" (func 56)) + (export \"as-convert-operand\" (func 57)) + (export \"as-memory.grow-size\" (func 58)) + (elem (;0;) (i32.const 0) 36)) + "; + 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 217 +fn c1_l217_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l217_action_invoke"); + let result = instance.call("type-i32", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 218 +fn c2_l218_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l218_action_invoke"); + let result = instance.call("type-i64", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 219 +fn c3_l219_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l219_action_invoke"); + let result = instance.call("type-f32", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 220 +fn c4_l220_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l220_action_invoke"); + let result = instance.call("type-f64", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 222 +fn c5_l222_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l222_action_invoke"); + let result = instance.call("type-i32-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 223 +fn c6_l223_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l223_action_invoke"); + let result = instance.call("type-i64-value", &[]); + assert_eq!(result, Ok(Some(Value::I64(2 as i64)))); + result.map(|_| ()) +} + +// Line 224 +fn c7_l224_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l224_action_invoke"); + let result = instance.call("type-f32-value", &[]); + assert_eq!(result, Ok(Some(Value::F32((3.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 225 +fn c8_l225_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l225_action_invoke"); + let result = instance.call("type-f64-value", &[]); + assert_eq!(result, Ok(Some(Value::F64((4.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 227 +fn c9_l227_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l227_action_invoke"); + let result = instance.call("nullary", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 228 +fn c10_l228_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c10_l228_action_invoke"); + let result = instance.call("unary", &[]); + assert_eq!(result, Ok(Some(Value::F64((3.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 230 +fn c11_l230_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c11_l230_action_invoke"); + let result = instance.call("as-func-first", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 231 +fn c12_l231_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c12_l231_action_invoke"); + let result = instance.call("as-func-mid", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 232 +fn c13_l232_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c13_l232_action_invoke"); + let result = instance.call("as-func-last", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 233 +fn c14_l233_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c14_l233_action_invoke"); + let result = instance.call("as-func-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 235 +fn c15_l235_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c15_l235_action_invoke"); + let result = instance.call("as-block-first", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 236 +fn c16_l236_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c16_l236_action_invoke"); + let result = instance.call("as-block-mid", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 237 +fn c17_l237_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c17_l237_action_invoke"); + let result = instance.call("as-block-last", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 238 +fn c18_l238_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c18_l238_action_invoke"); + let result = instance.call("as-block-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 240 +fn c19_l240_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c19_l240_action_invoke"); + let result = instance.call("as-loop-first", &[]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 241 +fn c20_l241_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c20_l241_action_invoke"); + let result = instance.call("as-loop-mid", &[]); + assert_eq!(result, Ok(Some(Value::I32(4 as i32)))); + result.map(|_| ()) +} + +// Line 242 +fn c21_l242_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c21_l242_action_invoke"); + let result = instance.call("as-loop-last", &[]); + assert_eq!(result, Ok(Some(Value::I32(5 as i32)))); + result.map(|_| ()) +} + +// Line 244 +fn c22_l244_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c22_l244_action_invoke"); + let result = instance.call("as-br-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 246 +fn c23_l246_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c23_l246_action_invoke"); + let result = instance.call("as-br_if-cond", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 247 +fn c24_l247_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c24_l247_action_invoke"); + let result = instance.call("as-br_if-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(8 as i32)))); + result.map(|_| ()) +} + +// Line 248 +fn c25_l248_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c25_l248_action_invoke"); + let result = instance.call("as-br_if-value-cond", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 250 +fn c26_l250_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c26_l250_action_invoke"); + let result = instance.call("as-br_table-index", &[]); + assert_eq!(result, Ok(Some(Value::I64(9 as i64)))); + result.map(|_| ()) +} + +// Line 251 +fn c27_l251_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c27_l251_action_invoke"); + let result = instance.call("as-br_table-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); + result.map(|_| ()) +} + +// Line 252 +fn c28_l252_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c28_l252_action_invoke"); + let result = instance.call("as-br_table-value-index", &[]); + assert_eq!(result, Ok(Some(Value::I32(11 as i32)))); + result.map(|_| ()) +} + +// Line 254 +fn c29_l254_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c29_l254_action_invoke"); + let result = instance.call("as-return-value", &[]); + assert_eq!(result, Ok(Some(Value::I64(7 as i64)))); + result.map(|_| ()) +} + +// Line 256 +fn c30_l256_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c30_l256_action_invoke"); + let result = instance.call("as-if-cond", &[]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 257 +fn c31_l257_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c31_l257_action_invoke"); + let result = instance.call("as-if-then", &[Value::I32(1 as i32), Value::I32(6 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 258 +fn c32_l258_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c32_l258_action_invoke"); + let result = instance.call("as-if-then", &[Value::I32(0 as i32), Value::I32(6 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); + result.map(|_| ()) +} + +// Line 259 +fn c33_l259_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c33_l259_action_invoke"); + let result = instance.call("as-if-else", &[Value::I32(0 as i32), Value::I32(6 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(4 as i32)))); + result.map(|_| ()) +} + +// Line 260 +fn c34_l260_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c34_l260_action_invoke"); + let result = instance.call("as-if-else", &[Value::I32(1 as i32), Value::I32(6 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); + result.map(|_| ()) +} + +// Line 262 +fn c35_l262_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c35_l262_action_invoke"); + let result = instance.call("as-select-first", &[Value::I32(0 as i32), Value::I32(6 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(5 as i32)))); + result.map(|_| ()) +} + +// Line 263 +fn c36_l263_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c36_l263_action_invoke"); + let result = instance.call("as-select-first", &[Value::I32(1 as i32), Value::I32(6 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(5 as i32)))); + result.map(|_| ()) +} + +// Line 264 +fn c37_l264_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c37_l264_action_invoke"); + let result = instance.call("as-select-second", &[Value::I32(0 as i32), Value::I32(6 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); + result.map(|_| ()) +} + +// Line 265 +fn c38_l265_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c38_l265_action_invoke"); + let result = instance.call("as-select-second", &[Value::I32(1 as i32), Value::I32(6 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(6 as i32)))); + result.map(|_| ()) +} + +// Line 266 +fn c39_l266_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c39_l266_action_invoke"); + let result = instance.call("as-select-cond", &[]); + assert_eq!(result, Ok(Some(Value::I32(7 as i32)))); + result.map(|_| ()) +} + +// Line 268 +fn c40_l268_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c40_l268_action_invoke"); + let result = instance.call("as-call-first", &[]); + assert_eq!(result, Ok(Some(Value::I32(12 as i32)))); + result.map(|_| ()) +} + +// Line 269 +fn c41_l269_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c41_l269_action_invoke"); + let result = instance.call("as-call-mid", &[]); + assert_eq!(result, Ok(Some(Value::I32(13 as i32)))); + result.map(|_| ()) +} + +// Line 270 +fn c42_l270_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c42_l270_action_invoke"); + let result = instance.call("as-call-last", &[]); + assert_eq!(result, Ok(Some(Value::I32(14 as i32)))); + result.map(|_| ()) +} + +// Line 272 +fn c43_l272_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c43_l272_action_invoke"); + let result = instance.call("as-call_indirect-func", &[]); + assert_eq!(result, Ok(Some(Value::I32(20 as i32)))); + result.map(|_| ()) +} + +// Line 273 +fn c44_l273_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c44_l273_action_invoke"); + let result = instance.call("as-call_indirect-first", &[]); + assert_eq!(result, Ok(Some(Value::I32(21 as i32)))); + result.map(|_| ()) +} + +// Line 274 +fn c45_l274_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c45_l274_action_invoke"); + let result = instance.call("as-call_indirect-mid", &[]); + assert_eq!(result, Ok(Some(Value::I32(22 as i32)))); + result.map(|_| ()) +} + +// Line 275 +fn c46_l275_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c46_l275_action_invoke"); + let result = instance.call("as-call_indirect-last", &[]); + assert_eq!(result, Ok(Some(Value::I32(23 as i32)))); + result.map(|_| ()) +} + +// Line 277 +fn c47_l277_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c47_l277_action_invoke"); + let result = instance.call("as-set_local-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(17 as i32)))); + result.map(|_| ()) +} + +// Line 279 +fn c48_l279_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c48_l279_action_invoke"); + let result = instance.call("as-load-address", &[]); + assert_eq!(result, Ok(Some(Value::F32((1.7f32).to_bits())))); + result.map(|_| ()) +} + +// Line 280 +fn c49_l280_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c49_l280_action_invoke"); + let result = instance.call("as-loadN-address", &[]); + assert_eq!(result, Ok(Some(Value::I64(30 as i64)))); + result.map(|_| ()) +} + +// Line 282 +fn c50_l282_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c50_l282_action_invoke"); + let result = instance.call("as-store-address", &[]); + assert_eq!(result, Ok(Some(Value::I32(30 as i32)))); + result.map(|_| ()) +} + +// Line 283 +fn c51_l283_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c51_l283_action_invoke"); + let result = instance.call("as-store-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(31 as i32)))); + result.map(|_| ()) +} + +// Line 284 +fn c52_l284_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c52_l284_action_invoke"); + let result = instance.call("as-storeN-address", &[]); + assert_eq!(result, Ok(Some(Value::I32(32 as i32)))); + result.map(|_| ()) +} + +// Line 285 +fn c53_l285_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c53_l285_action_invoke"); + let result = instance.call("as-storeN-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(33 as i32)))); + result.map(|_| ()) +} + +// Line 287 +fn c54_l287_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c54_l287_action_invoke"); + let result = instance.call("as-unary-operand", &[]); + assert_eq!(result, Ok(Some(Value::F32((3.4f32).to_bits())))); + result.map(|_| ()) +} + +// Line 289 +fn c55_l289_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c55_l289_action_invoke"); + let result = instance.call("as-binary-left", &[]); + assert_eq!(result, Ok(Some(Value::I32(3 as i32)))); + result.map(|_| ()) +} + +// Line 290 +fn c56_l290_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c56_l290_action_invoke"); + let result = instance.call("as-binary-right", &[]); + assert_eq!(result, Ok(Some(Value::I64(45 as i64)))); + result.map(|_| ()) +} + +// Line 292 +fn c57_l292_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c57_l292_action_invoke"); + let result = instance.call("as-test-operand", &[]); + assert_eq!(result, Ok(Some(Value::I32(44 as i32)))); + result.map(|_| ()) +} + +// Line 294 +fn c58_l294_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c58_l294_action_invoke"); + let result = instance.call("as-compare-left", &[]); + assert_eq!(result, Ok(Some(Value::I32(43 as i32)))); + result.map(|_| ()) +} + +// Line 295 +fn c59_l295_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c59_l295_action_invoke"); + let result = instance.call("as-compare-right", &[]); + assert_eq!(result, Ok(Some(Value::I32(42 as i32)))); + result.map(|_| ()) +} + +// Line 297 +fn c60_l297_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c60_l297_action_invoke"); + let result = instance.call("as-convert-operand", &[]); + assert_eq!(result, Ok(Some(Value::I32(41 as i32)))); + result.map(|_| ()) +} + +// Line 299 +fn c61_l299_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c61_l299_action_invoke"); + let result = instance.call("as-memory.grow-size", &[]); + assert_eq!(result, Ok(Some(Value::I32(40 as i32)))); + result.map(|_| ()) +} + +// Line 302 +#[test] +fn c62_l302_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 5, 1, 3, 0, 15, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 306 +#[test] +fn c63_l306_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 6, 1, 4, 0, 1, 15, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 310 +#[test] +fn c64_l310_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 1, 15, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l217_action_invoke(&mut instance); + c2_l218_action_invoke(&mut instance); + c3_l219_action_invoke(&mut instance); + c4_l220_action_invoke(&mut instance); + c5_l222_action_invoke(&mut instance); + c6_l223_action_invoke(&mut instance); + c7_l224_action_invoke(&mut instance); + c8_l225_action_invoke(&mut instance); + c9_l227_action_invoke(&mut instance); + c10_l228_action_invoke(&mut instance); + c11_l230_action_invoke(&mut instance); + c12_l231_action_invoke(&mut instance); + c13_l232_action_invoke(&mut instance); + c14_l233_action_invoke(&mut instance); + c15_l235_action_invoke(&mut instance); + c16_l236_action_invoke(&mut instance); + c17_l237_action_invoke(&mut instance); + c18_l238_action_invoke(&mut instance); + c19_l240_action_invoke(&mut instance); + c20_l241_action_invoke(&mut instance); + c21_l242_action_invoke(&mut instance); + c22_l244_action_invoke(&mut instance); + c23_l246_action_invoke(&mut instance); + c24_l247_action_invoke(&mut instance); + c25_l248_action_invoke(&mut instance); + c26_l250_action_invoke(&mut instance); + c27_l251_action_invoke(&mut instance); + c28_l252_action_invoke(&mut instance); + c29_l254_action_invoke(&mut instance); + c30_l256_action_invoke(&mut instance); + c31_l257_action_invoke(&mut instance); + c32_l258_action_invoke(&mut instance); + c33_l259_action_invoke(&mut instance); + c34_l260_action_invoke(&mut instance); + c35_l262_action_invoke(&mut instance); + c36_l263_action_invoke(&mut instance); + c37_l264_action_invoke(&mut instance); + c38_l265_action_invoke(&mut instance); + c39_l266_action_invoke(&mut instance); + c40_l268_action_invoke(&mut instance); + c41_l269_action_invoke(&mut instance); + c42_l270_action_invoke(&mut instance); + c43_l272_action_invoke(&mut instance); + c44_l273_action_invoke(&mut instance); + c45_l274_action_invoke(&mut instance); + c46_l275_action_invoke(&mut instance); + c47_l277_action_invoke(&mut instance); + c48_l279_action_invoke(&mut instance); + c49_l280_action_invoke(&mut instance); + c50_l282_action_invoke(&mut instance); + c51_l283_action_invoke(&mut instance); + c52_l284_action_invoke(&mut instance); + c53_l285_action_invoke(&mut instance); + c54_l287_action_invoke(&mut instance); + c55_l289_action_invoke(&mut instance); + c56_l290_action_invoke(&mut instance); + c57_l292_action_invoke(&mut instance); + c58_l294_action_invoke(&mut instance); + c59_l295_action_invoke(&mut instance); + c60_l297_action_invoke(&mut instance); + c61_l299_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/select.rs b/lib/runtime/tests/spectests/select.rs new file mode 100644 index 000000000..2cdd4247d --- /dev/null +++ b/lib/runtime/tests/spectests/select.rs @@ -0,0 +1,430 @@ +// 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/select.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 1 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func (param i32 i32 i32) (result i32))) + (type (;1;) (func (param i64 i64 i32) (result i64))) + (type (;2;) (func (param f32 f32 i32) (result f32))) + (type (;3;) (func (param f64 f64 i32) (result f64))) + (type (;4;) (func (param i32) (result i32))) + (type (;5;) (func)) + (func (;0;) (type 0) (param i32 i32 i32) (result i32) + get_local 0 + get_local 1 + get_local 2 + select) + (func (;1;) (type 1) (param i64 i64 i32) (result i64) + get_local 0 + get_local 1 + get_local 2 + select) + (func (;2;) (type 2) (param f32 f32 i32) (result f32) + get_local 0 + get_local 1 + get_local 2 + select) + (func (;3;) (type 3) (param f64 f64 i32) (result f64) + get_local 0 + get_local 1 + get_local 2 + select) + (func (;4;) (type 4) (param i32) (result i32) + unreachable + i32.const 0 + get_local 0 + select) + (func (;5;) (type 4) (param i32) (result i32) + i32.const 0 + unreachable + get_local 0 + select) + (func (;6;) (type 5) + unreachable + select + unreachable + i32.const 0 + select + unreachable + i32.const 0 + i32.const 0 + select + unreachable + f32.const 0x0p+0 (;=0;) + i32.const 0 + select + unreachable) + (export \"select_i32\" (func 0)) + (export \"select_i64\" (func 1)) + (export \"select_f32\" (func 2)) + (export \"select_f64\" (func 3)) + (export \"select_trap_l\" (func 4)) + (export \"select_trap_r\" (func 5)) + (export \"select_unreached\" (func 6))) + "; + 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 31 +fn c1_l31_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l31_action_invoke"); + let result = instance.call("select_i32", &[Value::I32(1 as i32), Value::I32(2 as i32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 32 +fn c2_l32_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l32_action_invoke"); + let result = instance.call("select_i64", &[Value::I64(2 as i64), Value::I64(1 as i64), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(2 as i64)))); + result.map(|_| ()) +} + +// Line 33 +fn c3_l33_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l33_action_invoke"); + let result = instance.call("select_f32", &[Value::F32((1.0f32).to_bits()), Value::F32((2.0f32).to_bits()), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 34 +fn c4_l34_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l34_action_invoke"); + let result = instance.call("select_f64", &[Value::F64((1.0f64).to_bits()), Value::F64((2.0f64).to_bits()), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 36 +fn c5_l36_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l36_action_invoke"); + let result = instance.call("select_i32", &[Value::I32(1 as i32), Value::I32(2 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(2 as i32)))); + result.map(|_| ()) +} + +// Line 37 +fn c6_l37_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l37_action_invoke"); + let result = instance.call("select_i32", &[Value::I32(2 as i32), Value::I32(1 as i32), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 38 +fn c7_l38_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l38_action_invoke"); + let result = instance.call("select_i64", &[Value::I64(2 as i64), Value::I64(1 as i64), Value::I32(-1 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(2 as i64)))); + result.map(|_| ()) +} + +// Line 39 +fn c8_l39_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l39_action_invoke"); + let result = instance.call("select_i64", &[Value::I64(2 as i64), Value::I64(1 as i64), Value::I32(-252645136 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(2 as i64)))); + result.map(|_| ()) +} + +// Line 41 +fn c9_l41_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l41_action_invoke"); + let result = instance.call("select_f32", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((1.0f32).to_bits()), Value::I32(1 as i32)]); + 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 42 +fn c10_l42_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c10_l42_action_invoke"); + let result = instance.call("select_f32", &[Value::F32(f32::from_bits(2139226884) as u32), Value::F32((1.0f32).to_bits()), Value::I32(1 as i32)]); + let expected = f32::from_bits(2139226884); + 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 43 +fn c11_l43_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c11_l43_action_invoke"); + let result = instance.call("select_f32", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((1.0f32).to_bits()), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 44 +fn c12_l44_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c12_l44_action_invoke"); + let result = instance.call("select_f32", &[Value::F32(f32::from_bits(2139226884) as u32), Value::F32((1.0f32).to_bits()), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 45 +fn c13_l45_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c13_l45_action_invoke"); + let result = instance.call("select_f32", &[Value::F32((2.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((2.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 46 +fn c14_l46_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c14_l46_action_invoke"); + let result = instance.call("select_f32", &[Value::F32((2.0f32).to_bits()), Value::F32(f32::from_bits(2139226884) as u32), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::F32((2.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 47 +fn c15_l47_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c15_l47_action_invoke"); + let result = instance.call("select_f32", &[Value::F32((2.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32), Value::I32(0 as i32)]); + 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 48 +fn c16_l48_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c16_l48_action_invoke"); + let result = instance.call("select_f32", &[Value::F32((2.0f32).to_bits()), Value::F32(f32::from_bits(2139226884) as u32), Value::I32(0 as i32)]); + let expected = f32::from_bits(2139226884); + 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 50 +fn c17_l50_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c17_l50_action_invoke"); + let result = instance.call("select_f64", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((1.0f64).to_bits()), Value::I32(1 as i32)]); + let expected = f64::from_bits(9221120237041090560); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 51 +fn c18_l51_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c18_l51_action_invoke"); + let result = instance.call("select_f64", &[Value::F64(f64::from_bits(9218868437227537156) as u64), Value::F64((1.0f64).to_bits()), Value::I32(1 as i32)]); + let expected = f64::from_bits(9218868437227537156); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 52 +fn c19_l52_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c19_l52_action_invoke"); + let result = instance.call("select_f64", &[Value::F64(f64::from_bits(9221120237041090560) as u64), Value::F64((1.0f64).to_bits()), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 53 +fn c20_l53_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c20_l53_action_invoke"); + let result = instance.call("select_f64", &[Value::F64(f64::from_bits(9218868437227537156) as u64), Value::F64((1.0f64).to_bits()), Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((1.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 54 +fn c21_l54_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c21_l54_action_invoke"); + let result = instance.call("select_f64", &[Value::F64((2.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((2.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 55 +fn c22_l55_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c22_l55_action_invoke"); + let result = instance.call("select_f64", &[Value::F64((2.0f64).to_bits()), Value::F64(f64::from_bits(9218868437227537156) as u64), Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((2.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 56 +fn c23_l56_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c23_l56_action_invoke"); + let result = instance.call("select_f64", &[Value::F64((2.0f64).to_bits()), Value::F64(f64::from_bits(9221120237041090560) as u64), Value::I32(0 as i32)]); + let expected = f64::from_bits(9221120237041090560); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 57 +fn c24_l57_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c24_l57_action_invoke"); + let result = instance.call("select_f64", &[Value::F64((2.0f64).to_bits()), Value::F64(f64::from_bits(9218868437227537156) as u64), Value::I32(0 as i32)]); + let expected = f64::from_bits(9218868437227537156); + if let Value::F64(result) = result.clone().unwrap().unwrap() { + assert!((result as f64).is_nan()); + assert_eq!((result as f64).is_sign_positive(), (expected as f64).is_sign_positive()); + } else { + panic!("Unexpected result type {:?}", result); + } + result.map(|_| ()) +} + +// Line 59 +fn c25_l59_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c25_l59_action_invoke"); + let result = instance.call("select_trap_l", &[Value::I32(1 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c25_l59_assert_trap() { + let mut instance = create_module_1(); + let result = c25_l59_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 60 +fn c26_l60_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c26_l60_action_invoke"); + let result = instance.call("select_trap_l", &[Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c26_l60_assert_trap() { + let mut instance = create_module_1(); + let result = c26_l60_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 61 +fn c27_l61_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c27_l61_action_invoke"); + let result = instance.call("select_trap_r", &[Value::I32(1 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c27_l61_assert_trap() { + let mut instance = create_module_1(); + let result = c27_l61_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 62 +fn c28_l62_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c28_l62_action_invoke"); + let result = instance.call("select_trap_r", &[Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c28_l62_assert_trap() { + let mut instance = create_module_1(); + let result = c28_l62_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 65 +#[test] +fn c29_l65_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 0, 1, 1, 65, 1, 27, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l31_action_invoke(&mut instance); + c2_l32_action_invoke(&mut instance); + c3_l33_action_invoke(&mut instance); + c4_l34_action_invoke(&mut instance); + c5_l36_action_invoke(&mut instance); + c6_l37_action_invoke(&mut instance); + c7_l38_action_invoke(&mut instance); + c8_l39_action_invoke(&mut instance); + c9_l41_action_invoke(&mut instance); + c10_l42_action_invoke(&mut instance); + c11_l43_action_invoke(&mut instance); + c12_l44_action_invoke(&mut instance); + c13_l45_action_invoke(&mut instance); + c14_l46_action_invoke(&mut instance); + c15_l47_action_invoke(&mut instance); + c16_l48_action_invoke(&mut instance); + c17_l50_action_invoke(&mut instance); + c18_l51_action_invoke(&mut instance); + c19_l52_action_invoke(&mut instance); + c20_l53_action_invoke(&mut instance); + c21_l54_action_invoke(&mut instance); + c22_l55_action_invoke(&mut instance); + c23_l56_action_invoke(&mut instance); + c24_l57_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/set_local.rs b/lib/runtime/tests/spectests/set_local.rs new file mode 100644 index 000000000..64c538e68 --- /dev/null +++ b/lib/runtime/tests/spectests/set_local.rs @@ -0,0 +1,418 @@ +// 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/set_local.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 3 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func)) + (type (;1;) (func (param i32))) + (type (;2;) (func (param i64))) + (type (;3;) (func (param f32))) + (type (;4;) (func (param f64))) + (type (;5;) (func (param i64 f32 f64 i32 i32))) + (type (;6;) (func (param i64 f32 f64 i32 i32) (result i64))) + (func (;0;) (type 0) + (local i32) + i32.const 0 + set_local 0) + (func (;1;) (type 0) + (local i64) + i64.const 0 + set_local 0) + (func (;2;) (type 0) + (local f32) + f32.const 0x0p+0 (;=0;) + set_local 0) + (func (;3;) (type 0) + (local f64) + f64.const 0x0p+0 (;=0;) + set_local 0) + (func (;4;) (type 1) (param i32) + i32.const 10 + set_local 0) + (func (;5;) (type 2) (param i64) + i64.const 11 + set_local 0) + (func (;6;) (type 3) (param f32) + f32.const 0x1.633334p+3 (;=11.1;) + set_local 0) + (func (;7;) (type 4) (param f64) + f64.const 0x1.8666666666666p+3 (;=12.2;) + set_local 0) + (func (;8;) (type 5) (param i64 f32 f64 i32 i32) + (local f32 i64 i64 f64) + i64.const 0 + set_local 0 + f32.const 0x0p+0 (;=0;) + set_local 1 + f64.const 0x0p+0 (;=0;) + set_local 2 + i32.const 0 + set_local 3 + i32.const 0 + set_local 4 + f32.const 0x0p+0 (;=0;) + set_local 5 + i64.const 0 + set_local 6 + i64.const 0 + set_local 7 + f64.const 0x0p+0 (;=0;) + set_local 8) + (func (;9;) (type 6) (param i64 f32 f64 i32 i32) (result i64) + (local f32 i64 i64 f64) + f32.const -0x1.333334p-2 (;=-0.3;) + set_local 1 + i32.const 40 + set_local 3 + i32.const -7 + set_local 4 + f32.const 0x1.6p+2 (;=5.5;) + set_local 5 + i64.const 6 + set_local 6 + f64.const 0x1p+3 (;=8;) + set_local 8 + get_local 0 + f64.convert_u/i64 + get_local 1 + f64.promote/f32 + get_local 2 + get_local 3 + f64.convert_u/i32 + get_local 4 + f64.convert_s/i32 + get_local 5 + f64.promote/f32 + get_local 6 + f64.convert_u/i64 + get_local 7 + f64.convert_u/i64 + get_local 8 + f64.add + f64.add + f64.add + f64.add + f64.add + f64.add + f64.add + f64.add + i64.trunc_s/f64) + (export \"type-local-i32\" (func 0)) + (export \"type-local-i64\" (func 1)) + (export \"type-local-f32\" (func 2)) + (export \"type-local-f64\" (func 3)) + (export \"type-param-i32\" (func 4)) + (export \"type-param-i64\" (func 5)) + (export \"type-param-f32\" (func 6)) + (export \"type-param-f64\" (func 7)) + (export \"type-mixed\" (func 8)) + (export \"write\" (func 9))) + "; + 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 68 +fn c1_l68_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l68_action_invoke"); + let result = instance.call("type-local-i32", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 69 +fn c2_l69_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l69_action_invoke"); + let result = instance.call("type-local-i64", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 70 +fn c3_l70_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l70_action_invoke"); + let result = instance.call("type-local-f32", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 71 +fn c4_l71_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l71_action_invoke"); + let result = instance.call("type-local-f64", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 73 +fn c5_l73_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l73_action_invoke"); + let result = instance.call("type-param-i32", &[Value::I32(2 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 74 +fn c6_l74_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l74_action_invoke"); + let result = instance.call("type-param-i64", &[Value::I64(3 as i64)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 75 +fn c7_l75_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l75_action_invoke"); + let result = instance.call("type-param-f32", &[Value::F32((4.4f32).to_bits())]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 76 +fn c8_l76_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l76_action_invoke"); + let result = instance.call("type-param-f64", &[Value::F64((5.5f64).to_bits())]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 79 +fn c9_l79_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l79_action_invoke"); + let result = instance.call("type-mixed", &[Value::I64(1 as i64), Value::F32((2.2f32).to_bits()), Value::F64((3.3f64).to_bits()), Value::I32(4 as i32), Value::I32(5 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 85 +fn c10_l85_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c10_l85_action_invoke"); + let result = instance.call("write", &[Value::I64(1 as i64), Value::F32((2.0f32).to_bits()), Value::F64((3.3f64).to_bits()), Value::I32(4 as i32), Value::I32(5 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(56 as i64)))); + result.map(|_| ()) +} + +// Line 95 +#[test] +fn c11_l95_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 10, 1, 8, 1, 1, 127, 65, 0, 33, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 101 +#[test] +fn c12_l101_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 14, 1, 12, 1, 1, 125, 67, 0, 0, 0, 0, 33, 0, 69, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 107 +#[test] +fn c13_l107_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 2, 1, 124, 1, 126, 66, 0, 33, 1, 154, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 114 +#[test] +fn c14_l114_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 1, 1, 127, 1, 33, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 118 +#[test] +fn c15_l118_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 1, 1, 127, 67, 0, 0, 0, 0, 33, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 122 +#[test] +fn c16_l122_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 17, 1, 15, 1, 1, 125, 68, 0, 0, 0, 0, 0, 0, 0, 0, 33, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 126 +#[test] +fn c17_l126_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 19, 1, 17, 2, 1, 124, 1, 126, 68, 0, 0, 0, 0, 0, 0, 0, 0, 33, 1, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 134 +#[test] +fn c18_l134_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 127, 1, 126, 3, 2, 1, 0, 10, 6, 1, 4, 0, 32, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 138 +#[test] +fn c19_l138_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 125, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 32, 0, 69, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 142 +#[test] +fn c20_l142_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 2, 124, 126, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 32, 1, 154, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 147 +#[test] +fn c21_l147_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 127, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 1, 33, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 151 +#[test] +fn c22_l151_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 127, 0, 3, 2, 1, 0, 10, 11, 1, 9, 0, 67, 0, 0, 0, 0, 33, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 155 +#[test] +fn c23_l155_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 125, 0, 3, 2, 1, 0, 10, 15, 1, 13, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 33, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 159 +#[test] +fn c24_l159_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 2, 124, 126, 0, 3, 2, 1, 0, 10, 15, 1, 13, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 33, 1, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 167 +#[test] +fn c25_l167_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 10, 1, 8, 2, 1, 127, 1, 126, 32, 3, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 171 +#[test] +fn c26_l171_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 2, 1, 127, 1, 126, 32, 247, 164, 234, 6, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 176 +#[test] +fn c27_l176_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 2, 127, 126, 0, 3, 2, 1, 0, 10, 6, 1, 4, 0, 32, 2, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 180 +#[test] +fn c28_l180_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 14, 1, 12, 2, 1, 127, 1, 126, 32, 247, 242, 206, 212, 2, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 185 +#[test] +fn c29_l185_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 127, 0, 3, 2, 1, 0, 10, 10, 1, 8, 2, 1, 127, 1, 126, 32, 3, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 189 +#[test] +fn c30_l189_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 126, 0, 3, 2, 1, 0, 10, 13, 1, 11, 2, 1, 127, 1, 126, 32, 247, 168, 153, 102, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 194 +#[test] +fn c31_l194_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 125, 0, 3, 2, 1, 0, 10, 13, 1, 11, 1, 1, 127, 67, 0, 0, 0, 0, 33, 1, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 198 +#[test] +fn c32_l198_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 2, 126, 127, 0, 3, 2, 1, 0, 10, 13, 1, 11, 1, 1, 125, 67, 0, 0, 0, 0, 33, 1, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 202 +#[test] +fn c33_l202_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 126, 0, 3, 2, 1, 0, 10, 12, 1, 10, 2, 1, 124, 1, 126, 66, 0, 33, 1, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l68_action_invoke(&mut instance); + c2_l69_action_invoke(&mut instance); + c3_l70_action_invoke(&mut instance); + c4_l71_action_invoke(&mut instance); + c5_l73_action_invoke(&mut instance); + c6_l74_action_invoke(&mut instance); + c7_l75_action_invoke(&mut instance); + c8_l76_action_invoke(&mut instance); + c9_l79_action_invoke(&mut instance); + c10_l85_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/stack.rs b/lib/runtime/tests/spectests/stack.rs new file mode 100644 index 000000000..2ca326430 --- /dev/null +++ b/lib/runtime/tests/spectests/stack.rs @@ -0,0 +1,452 @@ +// 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/stack.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 1 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func (param i64) (result i64))) + (func (;0;) (type 0) (param i64) (result i64) + (local i64 i64) + get_local 0 + set_local 1 + i64.const 1 + set_local 2 + block ;; label = @1 + loop ;; label = @2 + get_local 1 + i64.const 0 + i64.eq + if ;; label = @3 + br 2 (;@1;) + else + get_local 1 + get_local 2 + i64.mul + set_local 2 + get_local 1 + i64.const 1 + i64.sub + set_local 1 + end + br 0 (;@2;) + end + end + get_local 2) + (func (;1;) (type 0) (param i64) (result i64) + (local i64 i64) + get_local 0 + set_local 1 + i64.const 1 + set_local 2 + block ;; label = @1 + loop ;; label = @2 + get_local 1 + i64.const 0 + i64.eq + if ;; label = @3 + br 2 (;@1;) + else + get_local 1 + get_local 2 + i64.mul + set_local 2 + get_local 1 + i64.const 1 + i64.sub + set_local 1 + end + br 0 (;@2;) + end + end + get_local 2) + (func (;2;) (type 0) (param i64) (result i64) + (local i64 i64) + get_local 0 + set_local 1 + i64.const 1 + set_local 2 + block ;; label = @1 + loop ;; label = @2 + get_local 1 + i64.const 0 + i64.eq + if ;; label = @3 + br 2 (;@1;) + else + get_local 1 + get_local 2 + i64.mul + set_local 2 + get_local 1 + i64.const 1 + i64.sub + set_local 1 + end + br 0 (;@2;) + end + end + get_local 2) + (func (;3;) (type 0) (param i64) (result i64) + (local i64 i64) + get_local 0 + set_local 1 + i64.const 1 + set_local 2 + block ;; label = @1 + loop ;; label = @2 + get_local 1 + i64.const 0 + i64.eq + if ;; label = @3 + br 2 (;@1;) + else + get_local 1 + get_local 2 + i64.mul + set_local 2 + get_local 1 + i64.const 1 + i64.sub + set_local 1 + end + br 0 (;@2;) + end + end + get_local 2) + (func (;4;) (type 0) (param i64) (result i64) + (local i64 i64) + get_local 0 + set_local 1 + i64.const 1 + set_local 2 + block ;; label = @1 + loop ;; label = @2 + get_local 1 + i64.const 0 + i64.eq + if ;; label = @3 + br 2 (;@1;) + else + get_local 1 + get_local 2 + i64.mul + set_local 2 + get_local 1 + i64.const 1 + i64.sub + set_local 1 + end + br 0 (;@2;) + end + end + get_local 2) + (export \"fac-expr\" (func 0)) + (export \"fac-stack\" (func 1)) + (export \"fac-stack-raw\" (func 2)) + (export \"fac-mixed\" (func 3)) + (export \"fac-mixed-raw\" (func 4))) + "; + 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 130 +fn c1_l130_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l130_action_invoke"); + let result = instance.call("fac-expr", &[Value::I64(25 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(7034535277573963776 as i64)))); + result.map(|_| ()) +} + +// Line 131 +fn c2_l131_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l131_action_invoke"); + let result = instance.call("fac-stack", &[Value::I64(25 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(7034535277573963776 as i64)))); + result.map(|_| ()) +} + +// Line 132 +fn c3_l132_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l132_action_invoke"); + let result = instance.call("fac-mixed", &[Value::I64(25 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(7034535277573963776 as i64)))); + result.map(|_| ()) +} + +// Line 137 + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l130_action_invoke(&mut instance); + c2_l131_action_invoke(&mut instance); + c3_l132_action_invoke(&mut instance); +} +fn create_module_2() -> Box { + let module_str = "(module + (type (;0;) (func)) + (type (;1;) (func (param i32))) + (type (;2;) (func (result i32))) + (func (;0;) (type 0) + block ;; label = @1 + i32.const 0 + call_indirect (type 0) + end + loop ;; label = @1 + i32.const 0 + call_indirect (type 0) + end + i32.const 0 + if ;; label = @1 + i32.const 0 + call_indirect (type 0) + end + i32.const 0 + if ;; label = @1 + i32.const 0 + call_indirect (type 0) + else + i32.const 0 + call_indirect (type 0) + end + block ;; label = @1 + i32.const 0 + call_indirect (type 0) + end + loop ;; label = @1 + i32.const 0 + call_indirect (type 0) + end + i32.const 0 + if ;; label = @1 + i32.const 0 + call_indirect (type 0) + end + i32.const 0 + if ;; label = @1 + i32.const 0 + call_indirect (type 0) + else + i32.const 0 + call_indirect (type 0) + end + block ;; label = @1 + i32.const 0 + i32.const 0 + call_indirect (type 1) + end + loop ;; label = @1 + i32.const 0 + i32.const 0 + call_indirect (type 1) + end + i32.const 0 + if ;; label = @1 + i32.const 0 + i32.const 0 + call_indirect (type 1) + end + i32.const 0 + if ;; label = @1 + i32.const 0 + i32.const 0 + call_indirect (type 1) + else + i32.const 0 + i32.const 0 + call_indirect (type 1) + end + block (result i32) ;; label = @1 + i32.const 0 + call_indirect (type 2) + end + drop + loop (result i32) ;; label = @1 + i32.const 0 + call_indirect (type 2) + end + drop + i32.const 0 + if (result i32) ;; label = @1 + i32.const 0 + call_indirect (type 2) + else + i32.const 0 + call_indirect (type 2) + end + drop + block ;; label = @1 + i32.const 0 + call_indirect (type 0) + end + loop ;; label = @1 + i32.const 0 + call_indirect (type 0) + end + i32.const 0 + if ;; label = @1 + i32.const 0 + call_indirect (type 0) + end + i32.const 0 + if ;; label = @1 + i32.const 0 + call_indirect (type 0) + else + i32.const 0 + call_indirect (type 0) + end + block ;; label = @1 + i32.const 0 + call_indirect (type 0) + end + loop ;; label = @1 + i32.const 0 + call_indirect (type 0) + end + i32.const 0 + if ;; label = @1 + i32.const 0 + call_indirect (type 0) + end + i32.const 0 + if ;; label = @1 + i32.const 0 + call_indirect (type 0) + else + i32.const 0 + call_indirect (type 0) + end + block ;; label = @1 + i32.const 0 + call_indirect (type 0) + end + loop ;; label = @1 + i32.const 0 + call_indirect (type 0) + end + i32.const 0 + if ;; label = @1 + i32.const 0 + call_indirect (type 0) + end + i32.const 0 + if ;; label = @1 + i32.const 0 + call_indirect (type 0) + else + i32.const 0 + call_indirect (type 0) + end + block ;; label = @1 + i32.const 0 + i32.const 0 + call_indirect (type 1) + end + loop ;; label = @1 + i32.const 0 + i32.const 0 + call_indirect (type 1) + end + i32.const 0 + if ;; label = @1 + i32.const 0 + i32.const 0 + call_indirect (type 1) + end + i32.const 0 + if ;; label = @1 + i32.const 0 + i32.const 0 + call_indirect (type 1) + else + i32.const 0 + i32.const 0 + call_indirect (type 1) + end + block (result i32) ;; label = @1 + i32.const 0 + call_indirect (type 2) + end + drop + loop (result i32) ;; label = @1 + i32.const 0 + call_indirect (type 2) + end + drop + i32.const 0 + if (result i32) ;; label = @1 + i32.const 0 + call_indirect (type 2) + else + i32.const 0 + call_indirect (type 2) + end + drop + block ;; label = @1 + i32.const 0 + call_indirect (type 0) + end + loop ;; label = @1 + i32.const 0 + call_indirect (type 0) + end + i32.const 0 + if ;; label = @1 + i32.const 0 + call_indirect (type 0) + end + i32.const 0 + if ;; label = @1 + i32.const 0 + call_indirect (type 0) + else + i32.const 0 + call_indirect (type 0) + end + i32.const 0 + call_indirect (type 0)) + (table (;0;) 1 anyfunc)) + "; + 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_2(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +#[test] +fn test_module_2() { + let mut instance = create_module_2(); + // We group the calls together + start_module_2(&mut instance); +} diff --git a/lib/runtime/tests/spectests/start.rs b/lib/runtime/tests/spectests/start.rs new file mode 100644 index 000000000..a33bbfebd --- /dev/null +++ b/lib/runtime/tests/spectests/start.rs @@ -0,0 +1,301 @@ +// 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/start.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 2 +#[test] +fn c0_l2_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 8, 1, 1, 10, 4, 1, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 7 +#[test] +fn c1_l7_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 8, 1, 0, 10, 7, 1, 5, 0, 65, 0, 15, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 14 +#[test] +fn c2_l14_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 127, 0, 3, 2, 1, 0, 8, 1, 0, 10, 4, 1, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 21 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func)) + (type (;1;) (func (result i32))) + (func (;0;) (type 0) + i32.const 0 + i32.const 0 + i32.load8_u + i32.const 1 + i32.add + i32.store8) + (func (;1;) (type 1) (result i32) + i32.const 0 + i32.load8_u + return) + (func (;2;) (type 0) + call 0 + call 0 + call 0) + (memory (;0;) 1 1) + (export \"inc\" (func 0)) + (export \"get\" (func 1)) + (start 2) + (data (;0;) (i32.const 0) \"A\")) + "; + 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 45 +fn c4_l45_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l45_action_invoke"); + let result = instance.call("get", &[]); + assert_eq!(result, Ok(Some(Value::I32(68 as i32)))); + result.map(|_| ()) +} + +// Line 46 +fn c5_l46_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l46_action_invoke"); + let result = instance.call("inc", &[]); + + result.map(|_| ()) +} + +// Line 47 +fn c6_l47_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l47_action_invoke"); + let result = instance.call("get", &[]); + assert_eq!(result, Ok(Some(Value::I32(69 as i32)))); + result.map(|_| ()) +} + +// Line 48 +fn c7_l48_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l48_action_invoke"); + let result = instance.call("inc", &[]); + + result.map(|_| ()) +} + +// Line 49 +fn c8_l49_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l49_action_invoke"); + let result = instance.call("get", &[]); + assert_eq!(result, Ok(Some(Value::I32(70 as i32)))); + result.map(|_| ()) +} + +// Line 51 + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c4_l45_action_invoke(&mut instance); + c5_l46_action_invoke(&mut instance); + c6_l47_action_invoke(&mut instance); + c7_l48_action_invoke(&mut instance); + c8_l49_action_invoke(&mut instance); +} +fn create_module_2() -> Box { + let module_str = "(module + (type (;0;) (func)) + (type (;1;) (func (result i32))) + (func (;0;) (type 0) + i32.const 0 + i32.const 0 + i32.load8_u + i32.const 1 + i32.add + i32.store8) + (func (;1;) (type 1) (result i32) + i32.const 0 + i32.load8_u + return) + (func (;2;) (type 0) + call 0 + call 0 + call 0) + (memory (;0;) 1 1) + (export \"inc\" (func 0)) + (export \"get\" (func 1)) + (start 2) + (data (;0;) (i32.const 0) \"A\")) + "; + 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_2(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 74 +fn c10_l74_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c10_l74_action_invoke"); + let result = instance.call("get", &[]); + assert_eq!(result, Ok(Some(Value::I32(68 as i32)))); + result.map(|_| ()) +} + +// Line 75 +fn c11_l75_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c11_l75_action_invoke"); + let result = instance.call("inc", &[]); + + result.map(|_| ()) +} + +// Line 76 +fn c12_l76_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c12_l76_action_invoke"); + let result = instance.call("get", &[]); + assert_eq!(result, Ok(Some(Value::I32(69 as i32)))); + result.map(|_| ()) +} + +// Line 77 +fn c13_l77_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c13_l77_action_invoke"); + let result = instance.call("inc", &[]); + + result.map(|_| ()) +} + +// Line 78 +fn c14_l78_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c14_l78_action_invoke"); + let result = instance.call("get", &[]); + assert_eq!(result, Ok(Some(Value::I32(70 as i32)))); + result.map(|_| ()) +} + +// Line 80 + +#[test] +fn test_module_2() { + let mut instance = create_module_2(); + // We group the calls together + start_module_2(&mut instance); + c10_l74_action_invoke(&mut instance); + c11_l75_action_invoke(&mut instance); + c12_l76_action_invoke(&mut instance); + c13_l77_action_invoke(&mut instance); + c14_l78_action_invoke(&mut instance); +} +fn create_module_3() -> Box { + let module_str = "(module + (type (;0;) (func (param i32))) + (type (;1;) (func)) + (import \"spectest\" \"print_i32\" (func (;0;) (type 0))) + (func (;1;) (type 1) + i32.const 1 + call 0) + (start 1)) + "; + 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_3(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 86 + +#[test] +fn test_module_3() { + let mut instance = create_module_3(); + // We group the calls together + start_module_3(&mut instance); +} +fn create_module_4() -> Box { + let module_str = "(module + (type (;0;) (func (param i32))) + (type (;1;) (func)) + (import \"spectest\" \"print_i32\" (func (;0;) (type 0))) + (func (;1;) (type 1) + i32.const 2 + call 0) + (start 1)) + "; + 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_4(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 92 + +#[test] +fn test_module_4() { + let mut instance = create_module_4(); + // We group the calls together + start_module_4(&mut instance); +} +fn create_module_5() -> Box { + let module_str = "(module + (type (;0;) (func)) + (import \"spectest\" \"print\" (func (;0;) (type 0))) + (start 0)) + "; + 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_5(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 98 + +#[test] +fn test_module_5() { + let mut instance = create_module_5(); + // We group the calls together + start_module_5(&mut instance); +} diff --git a/lib/runtime/tests/spectests/store_retval.rs b/lib/runtime/tests/spectests/store_retval.rs new file mode 100644 index 000000000..970a3d836 --- /dev/null +++ b/lib/runtime/tests/spectests/store_retval.rs @@ -0,0 +1,123 @@ +// 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/store_retval.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 2 +#[test] +fn c0_l2_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 127, 1, 127, 3, 2, 1, 0, 10, 8, 1, 6, 0, 65, 1, 33, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 6 +#[test] +fn c1_l6_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 126, 1, 126, 3, 2, 1, 0, 10, 8, 1, 6, 0, 66, 1, 33, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 10 +#[test] +fn c2_l10_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 125, 1, 125, 3, 2, 1, 0, 10, 11, 1, 9, 0, 67, 0, 0, 128, 63, 33, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 14 +#[test] +fn c3_l14_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 124, 1, 124, 3, 2, 1, 0, 10, 15, 1, 13, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 33, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 19 +#[test] +fn c4_l19_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 127, 1, 127, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 11, 1, 9, 0, 65, 0, 65, 1, 54, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 23 +#[test] +fn c5_l23_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 126, 1, 126, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 11, 1, 9, 0, 65, 0, 66, 1, 55, 3, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 27 +#[test] +fn c6_l27_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 125, 1, 125, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 14, 1, 12, 0, 65, 0, 67, 0, 0, 128, 63, 56, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 31 +#[test] +fn c7_l31_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 124, 1, 124, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 18, 1, 16, 0, 65, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 57, 3, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 36 +#[test] +fn c8_l36_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 127, 1, 127, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 11, 1, 9, 0, 65, 0, 65, 1, 58, 0, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 40 +#[test] +fn c9_l40_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 127, 1, 127, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 11, 1, 9, 0, 65, 0, 65, 1, 59, 1, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 44 +#[test] +fn c10_l44_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 126, 1, 126, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 11, 1, 9, 0, 65, 0, 66, 1, 60, 0, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 48 +#[test] +fn c11_l48_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 126, 1, 126, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 11, 1, 9, 0, 65, 0, 66, 1, 61, 1, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 52 +#[test] +fn c12_l52_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 126, 1, 126, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 11, 1, 9, 0, 65, 0, 66, 1, 62, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} diff --git a/lib/runtime/tests/spectests/switch.rs b/lib/runtime/tests/spectests/switch.rs new file mode 100644 index 000000000..8ae376744 --- /dev/null +++ b/lib/runtime/tests/spectests/switch.rs @@ -0,0 +1,402 @@ +// 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/switch.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 1 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func (param i32) (result i32))) + (type (;1;) (func (param i64) (result i64))) + (type (;2;) (func (result i32))) + (func (;0;) (type 0) (param i32) (result i32) + (local i32) + i32.const 100 + set_local 1 + block ;; label = @1 + block ;; label = @2 + block ;; label = @3 + block ;; label = @4 + block ;; label = @5 + block ;; label = @6 + block ;; label = @7 + block ;; label = @8 + block ;; label = @9 + block ;; label = @10 + get_local 0 + br_table 0 (;@10;) 1 (;@9;) 2 (;@8;) 3 (;@7;) 4 (;@6;) 5 (;@5;) 6 (;@4;) 8 (;@2;) 7 (;@3;) + end + get_local 0 + return + end + nop + end + end + i32.const 0 + get_local 0 + i32.sub + set_local 1 + br 5 (;@1;) + end + br 4 (;@1;) + end + i32.const 101 + set_local 1 + br 3 (;@1;) + end + i32.const 101 + set_local 1 + end + i32.const 102 + set_local 1 + end + end + get_local 1 + return) + (func (;1;) (type 1) (param i64) (result i64) + (local i64) + i64.const 100 + set_local 1 + block (result i64) ;; label = @1 + block ;; label = @2 + block ;; label = @3 + block ;; label = @4 + block ;; label = @5 + block ;; label = @6 + block ;; label = @7 + block ;; label = @8 + block ;; label = @9 + block ;; label = @10 + get_local 0 + i32.wrap/i64 + br_table 0 (;@10;) 1 (;@9;) 2 (;@8;) 3 (;@7;) 6 (;@4;) 5 (;@5;) 4 (;@6;) 8 (;@2;) 7 (;@3;) + end + get_local 0 + return + end + nop + end + end + i64.const 0 + get_local 0 + i64.sub + br 5 (;@1;) + end + i64.const 101 + set_local 1 + end + end + end + get_local 1 + br 1 (;@1;) + end + i64.const -5 + end + return) + (func (;2;) (type 0) (param i32) (result i32) + block (result i32) ;; label = @1 + i32.const 10 + block (result i32) ;; label = @2 + i32.const 100 + block (result i32) ;; label = @3 + i32.const 1000 + block (result i32) ;; label = @4 + i32.const 2 + get_local 0 + i32.mul + i32.const 3 + get_local 0 + i32.and + br_table 1 (;@3;) 2 (;@2;) 3 (;@1;) 0 (;@4;) + end + i32.add + end + i32.add + end + i32.add + end + return) + (func (;3;) (type 2) (result i32) + block ;; label = @1 + i32.const 0 + br_table 0 (;@1;) + end + i32.const 1) + (export \"stmt\" (func 0)) + (export \"expr\" (func 1)) + (export \"arg\" (func 2)) + (export \"corner\" (func 3))) + "; + 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 120 +fn c1_l120_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l120_action_invoke"); + let result = instance.call("stmt", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 121 +fn c2_l121_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l121_action_invoke"); + let result = instance.call("stmt", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-1 as i32)))); + result.map(|_| ()) +} + +// Line 122 +fn c3_l122_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l122_action_invoke"); + let result = instance.call("stmt", &[Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-2 as i32)))); + result.map(|_| ()) +} + +// Line 123 +fn c4_l123_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l123_action_invoke"); + let result = instance.call("stmt", &[Value::I32(3 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(-3 as i32)))); + result.map(|_| ()) +} + +// Line 124 +fn c5_l124_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l124_action_invoke"); + let result = instance.call("stmt", &[Value::I32(4 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(100 as i32)))); + result.map(|_| ()) +} + +// Line 125 +fn c6_l125_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l125_action_invoke"); + let result = instance.call("stmt", &[Value::I32(5 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(101 as i32)))); + result.map(|_| ()) +} + +// Line 126 +fn c7_l126_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l126_action_invoke"); + let result = instance.call("stmt", &[Value::I32(6 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(102 as i32)))); + result.map(|_| ()) +} + +// Line 127 +fn c8_l127_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l127_action_invoke"); + let result = instance.call("stmt", &[Value::I32(7 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(100 as i32)))); + result.map(|_| ()) +} + +// Line 128 +fn c9_l128_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l128_action_invoke"); + let result = instance.call("stmt", &[Value::I32(-10 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(102 as i32)))); + result.map(|_| ()) +} + +// Line 130 +fn c10_l130_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c10_l130_action_invoke"); + let result = instance.call("expr", &[Value::I64(0 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 131 +fn c11_l131_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c11_l131_action_invoke"); + let result = instance.call("expr", &[Value::I64(1 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-1 as i64)))); + result.map(|_| ()) +} + +// Line 132 +fn c12_l132_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c12_l132_action_invoke"); + let result = instance.call("expr", &[Value::I64(2 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-2 as i64)))); + result.map(|_| ()) +} + +// Line 133 +fn c13_l133_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c13_l133_action_invoke"); + let result = instance.call("expr", &[Value::I64(3 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-3 as i64)))); + result.map(|_| ()) +} + +// Line 134 +fn c14_l134_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c14_l134_action_invoke"); + let result = instance.call("expr", &[Value::I64(6 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(101 as i64)))); + result.map(|_| ()) +} + +// Line 135 +fn c15_l135_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c15_l135_action_invoke"); + let result = instance.call("expr", &[Value::I64(7 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(-5 as i64)))); + result.map(|_| ()) +} + +// Line 136 +fn c16_l136_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c16_l136_action_invoke"); + let result = instance.call("expr", &[Value::I64(-10 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(100 as i64)))); + result.map(|_| ()) +} + +// Line 138 +fn c17_l138_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c17_l138_action_invoke"); + let result = instance.call("arg", &[Value::I32(0 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(110 as i32)))); + result.map(|_| ()) +} + +// Line 139 +fn c18_l139_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c18_l139_action_invoke"); + let result = instance.call("arg", &[Value::I32(1 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(12 as i32)))); + result.map(|_| ()) +} + +// Line 140 +fn c19_l140_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c19_l140_action_invoke"); + let result = instance.call("arg", &[Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(4 as i32)))); + result.map(|_| ()) +} + +// Line 141 +fn c20_l141_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c20_l141_action_invoke"); + let result = instance.call("arg", &[Value::I32(3 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1116 as i32)))); + result.map(|_| ()) +} + +// Line 142 +fn c21_l142_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c21_l142_action_invoke"); + let result = instance.call("arg", &[Value::I32(4 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(118 as i32)))); + result.map(|_| ()) +} + +// Line 143 +fn c22_l143_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c22_l143_action_invoke"); + let result = instance.call("arg", &[Value::I32(5 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(20 as i32)))); + result.map(|_| ()) +} + +// Line 144 +fn c23_l144_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c23_l144_action_invoke"); + let result = instance.call("arg", &[Value::I32(6 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(12 as i32)))); + result.map(|_| ()) +} + +// Line 145 +fn c24_l145_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c24_l145_action_invoke"); + let result = instance.call("arg", &[Value::I32(7 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(1124 as i32)))); + result.map(|_| ()) +} + +// Line 146 +fn c25_l146_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c25_l146_action_invoke"); + let result = instance.call("arg", &[Value::I32(8 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(126 as i32)))); + result.map(|_| ()) +} + +// Line 148 +fn c26_l148_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c26_l148_action_invoke"); + let result = instance.call("corner", &[]); + assert_eq!(result, Ok(Some(Value::I32(1 as i32)))); + result.map(|_| ()) +} + +// Line 150 +#[test] +fn c27_l150_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 0, 14, 0, 3, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l120_action_invoke(&mut instance); + c2_l121_action_invoke(&mut instance); + c3_l122_action_invoke(&mut instance); + c4_l123_action_invoke(&mut instance); + c5_l124_action_invoke(&mut instance); + c6_l125_action_invoke(&mut instance); + c7_l126_action_invoke(&mut instance); + c8_l127_action_invoke(&mut instance); + c9_l128_action_invoke(&mut instance); + c10_l130_action_invoke(&mut instance); + c11_l131_action_invoke(&mut instance); + c12_l132_action_invoke(&mut instance); + c13_l133_action_invoke(&mut instance); + c14_l134_action_invoke(&mut instance); + c15_l135_action_invoke(&mut instance); + c16_l136_action_invoke(&mut instance); + c17_l138_action_invoke(&mut instance); + c18_l139_action_invoke(&mut instance); + c19_l140_action_invoke(&mut instance); + c20_l141_action_invoke(&mut instance); + c21_l142_action_invoke(&mut instance); + c22_l143_action_invoke(&mut instance); + c23_l144_action_invoke(&mut instance); + c24_l145_action_invoke(&mut instance); + c25_l146_action_invoke(&mut instance); + c26_l148_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/tee_local.rs b/lib/runtime/tests/spectests/tee_local.rs new file mode 100644 index 000000000..8326091f6 --- /dev/null +++ b/lib/runtime/tests/spectests/tee_local.rs @@ -0,0 +1,491 @@ +// 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/tee_local.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 3 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func (result i32))) + (type (;1;) (func (result i64))) + (type (;2;) (func (result f32))) + (type (;3;) (func (result f64))) + (type (;4;) (func (param i32) (result i32))) + (type (;5;) (func (param i64) (result i64))) + (type (;6;) (func (param f32) (result f32))) + (type (;7;) (func (param f64) (result f64))) + (type (;8;) (func (param i64 f32 f64 i32 i32))) + (type (;9;) (func (param i64 f32 f64 i32 i32) (result i64))) + (type (;10;) (func (param i64 f32 f64 i32 i32) (result f64))) + (func (;0;) (type 0) (result i32) + (local i32) + i32.const 0 + tee_local 0) + (func (;1;) (type 1) (result i64) + (local i64) + i64.const 0 + tee_local 0) + (func (;2;) (type 2) (result f32) + (local f32) + f32.const 0x0p+0 (;=0;) + tee_local 0) + (func (;3;) (type 3) (result f64) + (local f64) + f64.const 0x0p+0 (;=0;) + tee_local 0) + (func (;4;) (type 4) (param i32) (result i32) + i32.const 10 + tee_local 0) + (func (;5;) (type 5) (param i64) (result i64) + i64.const 11 + tee_local 0) + (func (;6;) (type 6) (param f32) (result f32) + f32.const 0x1.633334p+3 (;=11.1;) + tee_local 0) + (func (;7;) (type 7) (param f64) (result f64) + f64.const 0x1.8666666666666p+3 (;=12.2;) + tee_local 0) + (func (;8;) (type 8) (param i64 f32 f64 i32 i32) + (local f32 i64 i64 f64) + i64.const 0 + tee_local 0 + i64.eqz + drop + f32.const 0x0p+0 (;=0;) + tee_local 1 + f32.neg + drop + f64.const 0x0p+0 (;=0;) + tee_local 2 + f64.neg + drop + i32.const 0 + tee_local 3 + i32.eqz + drop + i32.const 0 + tee_local 4 + i32.eqz + drop + f32.const 0x0p+0 (;=0;) + tee_local 5 + f32.neg + drop + i64.const 0 + tee_local 6 + i64.eqz + drop + i64.const 0 + tee_local 7 + i64.eqz + drop + f64.const 0x0p+0 (;=0;) + tee_local 8 + f64.neg + drop) + (func (;9;) (type 9) (param i64 f32 f64 i32 i32) (result i64) + (local f32 i64 i64 f64) + f32.const -0x1.333334p-2 (;=-0.3;) + tee_local 1 + drop + i32.const 40 + tee_local 3 + drop + i32.const -7 + tee_local 4 + drop + f32.const 0x1.6p+2 (;=5.5;) + tee_local 5 + drop + i64.const 6 + tee_local 6 + drop + f64.const 0x1p+3 (;=8;) + tee_local 8 + drop + get_local 0 + f64.convert_u/i64 + get_local 1 + f64.promote/f32 + get_local 2 + get_local 3 + f64.convert_u/i32 + get_local 4 + f64.convert_s/i32 + get_local 5 + f64.promote/f32 + get_local 6 + f64.convert_u/i64 + get_local 7 + f64.convert_u/i64 + get_local 8 + f64.add + f64.add + f64.add + f64.add + f64.add + f64.add + f64.add + f64.add + i64.trunc_s/f64) + (func (;10;) (type 10) (param i64 f32 f64 i32 i32) (result f64) + (local f32 i64 i64 f64) + i64.const 1 + tee_local 0 + f64.convert_u/i64 + f32.const 0x1p+1 (;=2;) + tee_local 1 + f64.promote/f32 + f64.const 0x1.a666666666666p+1 (;=3.3;) + tee_local 2 + i32.const 4 + tee_local 3 + f64.convert_u/i32 + i32.const 5 + tee_local 4 + f64.convert_s/i32 + f32.const 0x1.6p+2 (;=5.5;) + tee_local 5 + f64.promote/f32 + i64.const 6 + tee_local 6 + f64.convert_u/i64 + i64.const 0 + tee_local 7 + f64.convert_u/i64 + f64.const 0x1p+3 (;=8;) + tee_local 8 + f64.add + f64.add + f64.add + f64.add + f64.add + f64.add + f64.add + f64.add) + (export \"type-local-i32\" (func 0)) + (export \"type-local-i64\" (func 1)) + (export \"type-local-f32\" (func 2)) + (export \"type-local-f64\" (func 3)) + (export \"type-param-i32\" (func 4)) + (export \"type-param-i64\" (func 5)) + (export \"type-param-f32\" (func 6)) + (export \"type-param-f64\" (func 7)) + (export \"type-mixed\" (func 8)) + (export \"write\" (func 9)) + (export \"result\" (func 10))) + "; + 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 98 +fn c1_l98_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l98_action_invoke"); + let result = instance.call("type-local-i32", &[]); + assert_eq!(result, Ok(Some(Value::I32(0 as i32)))); + result.map(|_| ()) +} + +// Line 99 +fn c2_l99_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l99_action_invoke"); + let result = instance.call("type-local-i64", &[]); + assert_eq!(result, Ok(Some(Value::I64(0 as i64)))); + result.map(|_| ()) +} + +// Line 100 +fn c3_l100_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l100_action_invoke"); + let result = instance.call("type-local-f32", &[]); + assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits())))); + result.map(|_| ()) +} + +// Line 101 +fn c4_l101_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l101_action_invoke"); + let result = instance.call("type-local-f64", &[]); + assert_eq!(result, Ok(Some(Value::F64((0.0f64).to_bits())))); + result.map(|_| ()) +} + +// Line 103 +fn c5_l103_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l103_action_invoke"); + let result = instance.call("type-param-i32", &[Value::I32(2 as i32)]); + assert_eq!(result, Ok(Some(Value::I32(10 as i32)))); + result.map(|_| ()) +} + +// Line 104 +fn c6_l104_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l104_action_invoke"); + let result = instance.call("type-param-i64", &[Value::I64(3 as i64)]); + assert_eq!(result, Ok(Some(Value::I64(11 as i64)))); + result.map(|_| ()) +} + +// Line 105 +fn c7_l105_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l105_action_invoke"); + let result = instance.call("type-param-f32", &[Value::F32((4.4f32).to_bits())]); + assert_eq!(result, Ok(Some(Value::F32((11.1f32).to_bits())))); + result.map(|_| ()) +} + +// Line 106 +fn c8_l106_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l106_action_invoke"); + let result = instance.call("type-param-f64", &[Value::F64((5.5f64).to_bits())]); + assert_eq!(result, Ok(Some(Value::F64((12.2f64).to_bits())))); + result.map(|_| ()) +} + +// Line 109 +fn c9_l109_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l109_action_invoke"); + let result = instance.call("type-mixed", &[Value::I64(1 as i64), Value::F32((2.2f32).to_bits()), Value::F64((3.3f64).to_bits()), Value::I32(4 as i32), Value::I32(5 as i32)]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 115 +fn c10_l115_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c10_l115_action_invoke"); + let result = instance.call("write", &[Value::I64(1 as i64), Value::F32((2.0f32).to_bits()), Value::F64((3.3f64).to_bits()), Value::I32(4 as i32), Value::I32(5 as i32)]); + assert_eq!(result, Ok(Some(Value::I64(56 as i64)))); + result.map(|_| ()) +} + +// Line 122 +fn c11_l122_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c11_l122_action_invoke"); + let result = instance.call("result", &[Value::I64(-1 as i64), Value::F32((-2.0f32).to_bits()), Value::F64((-3.3f64).to_bits()), Value::I32(-4 as i32), Value::I32(-5 as i32)]); + assert_eq!(result, Ok(Some(Value::F64((34.8f64).to_bits())))); + result.map(|_| ()) +} + +// Line 132 +#[test] +fn c12_l132_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 10, 1, 8, 1, 1, 127, 65, 0, 34, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 136 +#[test] +fn c13_l136_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 14, 1, 12, 1, 1, 125, 67, 0, 0, 0, 0, 34, 0, 69, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 140 +#[test] +fn c14_l140_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 2, 1, 124, 1, 126, 66, 0, 34, 1, 154, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 145 +#[test] +fn c15_l145_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 1, 1, 127, 1, 34, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 149 +#[test] +fn c16_l149_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 1, 1, 127, 67, 0, 0, 0, 0, 34, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 153 +#[test] +fn c17_l153_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 17, 1, 15, 1, 1, 125, 68, 0, 0, 0, 0, 0, 0, 0, 0, 34, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 157 +#[test] +fn c18_l157_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 19, 1, 17, 2, 1, 124, 1, 126, 68, 0, 0, 0, 0, 0, 0, 0, 0, 34, 1, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 165 +#[test] +fn c19_l165_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 127, 1, 126, 3, 2, 1, 0, 10, 6, 1, 4, 0, 32, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 169 +#[test] +fn c20_l169_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 125, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 32, 0, 69, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 173 +#[test] +fn c21_l173_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 2, 124, 126, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 32, 1, 154, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 178 +#[test] +fn c22_l178_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 127, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 1, 34, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 182 +#[test] +fn c23_l182_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 127, 0, 3, 2, 1, 0, 10, 11, 1, 9, 0, 67, 0, 0, 0, 0, 34, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 186 +#[test] +fn c24_l186_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 125, 0, 3, 2, 1, 0, 10, 15, 1, 13, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 34, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 190 +#[test] +fn c25_l190_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 2, 124, 126, 0, 3, 2, 1, 0, 10, 15, 1, 13, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 34, 1, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 198 +#[test] +fn c26_l198_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 10, 1, 8, 2, 1, 127, 1, 126, 32, 3, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 202 +#[test] +fn c27_l202_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 2, 1, 127, 1, 126, 32, 247, 164, 234, 6, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 207 +#[test] +fn c28_l207_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 2, 127, 126, 0, 3, 2, 1, 0, 10, 6, 1, 4, 0, 32, 2, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 211 +#[test] +fn c29_l211_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 14, 1, 12, 2, 1, 127, 1, 126, 32, 247, 242, 206, 212, 2, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 216 +#[test] +fn c30_l216_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 127, 0, 3, 2, 1, 0, 10, 10, 1, 8, 2, 1, 127, 1, 126, 32, 3, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 220 +#[test] +fn c31_l220_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 126, 0, 3, 2, 1, 0, 10, 13, 1, 11, 2, 1, 127, 1, 126, 32, 247, 168, 153, 102, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 225 +#[test] +fn c32_l225_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 125, 0, 3, 2, 1, 0, 10, 13, 1, 11, 1, 1, 127, 67, 0, 0, 0, 0, 34, 1, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 229 +#[test] +fn c33_l229_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 2, 126, 127, 0, 3, 2, 1, 0, 10, 13, 1, 11, 1, 1, 125, 67, 0, 0, 0, 0, 34, 1, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 233 +#[test] +fn c34_l233_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 1, 126, 0, 3, 2, 1, 0, 10, 12, 1, 10, 2, 1, 124, 1, 126, 66, 0, 34, 1, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c1_l98_action_invoke(&mut instance); + c2_l99_action_invoke(&mut instance); + c3_l100_action_invoke(&mut instance); + c4_l101_action_invoke(&mut instance); + c5_l103_action_invoke(&mut instance); + c6_l104_action_invoke(&mut instance); + c7_l105_action_invoke(&mut instance); + c8_l106_action_invoke(&mut instance); + c9_l109_action_invoke(&mut instance); + c10_l115_action_invoke(&mut instance); + c11_l122_action_invoke(&mut instance); +} diff --git a/lib/runtime/tests/spectests/token.rs b/lib/runtime/tests/spectests/token.rs new file mode 100644 index 000000000..eb9ea5b9b --- /dev/null +++ b/lib/runtime/tests/spectests/token.rs @@ -0,0 +1,35 @@ +// 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/token.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 4 +#[test] +fn c0_l4_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 40, 100, 114, 111, 112, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 48, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 8 +#[test] +fn c1_l8_assert_malformed() { + let wasm_binary = [40, 102, 117, 110, 99, 32, 98, 114, 32, 48, 100, 114, 111, 112, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} diff --git a/lib/runtime/tests/spectests/traps.rs b/lib/runtime/tests/spectests/traps.rs new file mode 100644 index 000000000..0965fb5fd --- /dev/null +++ b/lib/runtime/tests/spectests/traps.rs @@ -0,0 +1,749 @@ +// 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/traps.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 5 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func (param i32 i32))) + (type (;1;) (func (param i64 i64))) + (func (;0;) (type 0) (param i32 i32) + get_local 0 + get_local 1 + i32.div_s + drop) + (func (;1;) (type 0) (param i32 i32) + get_local 0 + get_local 1 + i32.div_u + drop) + (func (;2;) (type 1) (param i64 i64) + get_local 0 + get_local 1 + i64.div_s + drop) + (func (;3;) (type 1) (param i64 i64) + get_local 0 + get_local 1 + i64.div_u + drop) + (export \"no_dce.i32.div_s\" (func 0)) + (export \"no_dce.i32.div_u\" (func 1)) + (export \"no_dce.i64.div_s\" (func 2)) + (export \"no_dce.i64.div_u\" (func 3))) + "; + 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 16 +fn c1_l16_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l16_action_invoke"); + let result = instance.call("no_dce.i32.div_s", &[Value::I32(1 as i32), Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c1_l16_assert_trap() { + let mut instance = create_module_1(); + let result = c1_l16_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 17 +fn c2_l17_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l17_action_invoke"); + let result = instance.call("no_dce.i32.div_u", &[Value::I32(1 as i32), Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c2_l17_assert_trap() { + let mut instance = create_module_1(); + let result = c2_l17_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 18 +fn c3_l18_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l18_action_invoke"); + let result = instance.call("no_dce.i64.div_s", &[Value::I64(1 as i64), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c3_l18_assert_trap() { + let mut instance = create_module_1(); + let result = c3_l18_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 19 +fn c4_l19_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l19_action_invoke"); + let result = instance.call("no_dce.i64.div_u", &[Value::I64(1 as i64), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c4_l19_assert_trap() { + let mut instance = create_module_1(); + let result = c4_l19_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 20 +fn c5_l20_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l20_action_invoke"); + let result = instance.call("no_dce.i32.div_s", &[Value::I32(-2147483648 as i32), Value::I32(-1 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c5_l20_assert_trap() { + let mut instance = create_module_1(); + let result = c5_l20_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 21 +fn c6_l21_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l21_action_invoke"); + let result = instance.call("no_dce.i64.div_s", &[Value::I64(-9223372036854775808 as i64), Value::I64(-1 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c6_l21_assert_trap() { + let mut instance = create_module_1(); + let result = c6_l21_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 23 + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); +} +fn create_module_2() -> Box { + let module_str = "(module + (type (;0;) (func (param i32 i32))) + (type (;1;) (func (param i64 i64))) + (func (;0;) (type 0) (param i32 i32) + get_local 0 + get_local 1 + i32.rem_s + drop) + (func (;1;) (type 0) (param i32 i32) + get_local 0 + get_local 1 + i32.rem_u + drop) + (func (;2;) (type 1) (param i64 i64) + get_local 0 + get_local 1 + i64.rem_s + drop) + (func (;3;) (type 1) (param i64 i64) + get_local 0 + get_local 1 + i64.rem_u + drop) + (export \"no_dce.i32.rem_s\" (func 0)) + (export \"no_dce.i32.rem_u\" (func 1)) + (export \"no_dce.i64.rem_s\" (func 2)) + (export \"no_dce.i64.rem_u\" (func 3))) + "; + 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_2(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 34 +fn c8_l34_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l34_action_invoke"); + let result = instance.call("no_dce.i32.rem_s", &[Value::I32(1 as i32), Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c8_l34_assert_trap() { + let mut instance = create_module_2(); + let result = c8_l34_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 35 +fn c9_l35_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l35_action_invoke"); + let result = instance.call("no_dce.i32.rem_u", &[Value::I32(1 as i32), Value::I32(0 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c9_l35_assert_trap() { + let mut instance = create_module_2(); + let result = c9_l35_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 36 +fn c10_l36_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c10_l36_action_invoke"); + let result = instance.call("no_dce.i64.rem_s", &[Value::I64(1 as i64), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c10_l36_assert_trap() { + let mut instance = create_module_2(); + let result = c10_l36_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 37 +fn c11_l37_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c11_l37_action_invoke"); + let result = instance.call("no_dce.i64.rem_u", &[Value::I64(1 as i64), Value::I64(0 as i64)]); + + result.map(|_| ()) +} + +#[test] +fn c11_l37_assert_trap() { + let mut instance = create_module_2(); + let result = c11_l37_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 39 + +#[test] +fn test_module_2() { + let mut instance = create_module_2(); + // We group the calls together + start_module_2(&mut instance); +} +fn create_module_3() -> Box { + let module_str = "(module + (type (;0;) (func (param f32))) + (type (;1;) (func (param f64))) + (func (;0;) (type 0) (param f32) + get_local 0 + i32.trunc_s/f32 + drop) + (func (;1;) (type 0) (param f32) + get_local 0 + i32.trunc_u/f32 + drop) + (func (;2;) (type 1) (param f64) + get_local 0 + i32.trunc_s/f64 + drop) + (func (;3;) (type 1) (param f64) + get_local 0 + i32.trunc_u/f64 + drop) + (func (;4;) (type 0) (param f32) + get_local 0 + i64.trunc_s/f32 + drop) + (func (;5;) (type 0) (param f32) + get_local 0 + i64.trunc_u/f32 + drop) + (func (;6;) (type 1) (param f64) + get_local 0 + i64.trunc_s/f64 + drop) + (func (;7;) (type 1) (param f64) + get_local 0 + i64.trunc_u/f64 + drop) + (export \"no_dce.i32.trunc_s_f32\" (func 0)) + (export \"no_dce.i32.trunc_u_f32\" (func 1)) + (export \"no_dce.i32.trunc_s_f64\" (func 2)) + (export \"no_dce.i32.trunc_u_f64\" (func 3)) + (export \"no_dce.i64.trunc_s_f32\" (func 4)) + (export \"no_dce.i64.trunc_u_f32\" (func 5)) + (export \"no_dce.i64.trunc_s_f64\" (func 6)) + (export \"no_dce.i64.trunc_u_f64\" (func 7))) + "; + 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_3(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 50 +fn c13_l50_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c13_l50_action_invoke"); + let result = instance.call("no_dce.i32.trunc_s_f32", &[Value::F32(f32::from_bits(2143289344) as u32)]); + + result.map(|_| ()) +} + +#[test] +fn c13_l50_assert_trap() { + let mut instance = create_module_3(); + let result = c13_l50_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 51 +fn c14_l51_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c14_l51_action_invoke"); + let result = instance.call("no_dce.i32.trunc_u_f32", &[Value::F32(f32::from_bits(2143289344) as u32)]); + + result.map(|_| ()) +} + +#[test] +fn c14_l51_assert_trap() { + let mut instance = create_module_3(); + let result = c14_l51_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 52 +fn c15_l52_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c15_l52_action_invoke"); + let result = instance.call("no_dce.i32.trunc_s_f64", &[Value::F64(f64::from_bits(9221120237041090560) as u64)]); + + result.map(|_| ()) +} + +#[test] +fn c15_l52_assert_trap() { + let mut instance = create_module_3(); + let result = c15_l52_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 53 +fn c16_l53_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c16_l53_action_invoke"); + let result = instance.call("no_dce.i32.trunc_u_f64", &[Value::F64(f64::from_bits(9221120237041090560) as u64)]); + + result.map(|_| ()) +} + +#[test] +fn c16_l53_assert_trap() { + let mut instance = create_module_3(); + let result = c16_l53_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 54 +fn c17_l54_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c17_l54_action_invoke"); + let result = instance.call("no_dce.i64.trunc_s_f32", &[Value::F32(f32::from_bits(2143289344) as u32)]); + + result.map(|_| ()) +} + +#[test] +fn c17_l54_assert_trap() { + let mut instance = create_module_3(); + let result = c17_l54_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 55 +fn c18_l55_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c18_l55_action_invoke"); + let result = instance.call("no_dce.i64.trunc_u_f32", &[Value::F32(f32::from_bits(2143289344) as u32)]); + + result.map(|_| ()) +} + +#[test] +fn c18_l55_assert_trap() { + let mut instance = create_module_3(); + let result = c18_l55_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 56 +fn c19_l56_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c19_l56_action_invoke"); + let result = instance.call("no_dce.i64.trunc_s_f64", &[Value::F64(f64::from_bits(9221120237041090560) as u64)]); + + result.map(|_| ()) +} + +#[test] +fn c19_l56_assert_trap() { + let mut instance = create_module_3(); + let result = c19_l56_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 57 +fn c20_l57_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c20_l57_action_invoke"); + let result = instance.call("no_dce.i64.trunc_u_f64", &[Value::F64(f64::from_bits(9221120237041090560) as u64)]); + + result.map(|_| ()) +} + +#[test] +fn c20_l57_assert_trap() { + let mut instance = create_module_3(); + let result = c20_l57_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 59 + +#[test] +fn test_module_3() { + let mut instance = create_module_3(); + // We group the calls together + start_module_3(&mut instance); +} +fn create_module_4() -> Box { + let module_str = "(module + (type (;0;) (func (param i32))) + (func (;0;) (type 0) (param i32) + get_local 0 + i32.load + drop) + (func (;1;) (type 0) (param i32) + get_local 0 + i32.load16_s + drop) + (func (;2;) (type 0) (param i32) + get_local 0 + i32.load16_u + drop) + (func (;3;) (type 0) (param i32) + get_local 0 + i32.load8_s + drop) + (func (;4;) (type 0) (param i32) + get_local 0 + i32.load8_u + drop) + (func (;5;) (type 0) (param i32) + get_local 0 + i64.load + drop) + (func (;6;) (type 0) (param i32) + get_local 0 + i64.load32_s + drop) + (func (;7;) (type 0) (param i32) + get_local 0 + i64.load32_u + drop) + (func (;8;) (type 0) (param i32) + get_local 0 + i64.load16_s + drop) + (func (;9;) (type 0) (param i32) + get_local 0 + i64.load16_u + drop) + (func (;10;) (type 0) (param i32) + get_local 0 + i64.load8_s + drop) + (func (;11;) (type 0) (param i32) + get_local 0 + i64.load8_u + drop) + (func (;12;) (type 0) (param i32) + get_local 0 + f32.load + drop) + (func (;13;) (type 0) (param i32) + get_local 0 + f64.load + drop) + (memory (;0;) 1) + (export \"no_dce.i32.load\" (func 0)) + (export \"no_dce.i32.load16_s\" (func 1)) + (export \"no_dce.i32.load16_u\" (func 2)) + (export \"no_dce.i32.load8_s\" (func 3)) + (export \"no_dce.i32.load8_u\" (func 4)) + (export \"no_dce.i64.load\" (func 5)) + (export \"no_dce.i64.load32_s\" (func 6)) + (export \"no_dce.i64.load32_u\" (func 7)) + (export \"no_dce.i64.load16_s\" (func 8)) + (export \"no_dce.i64.load16_u\" (func 9)) + (export \"no_dce.i64.load8_s\" (func 10)) + (export \"no_dce.i64.load8_u\" (func 11)) + (export \"no_dce.f32.load\" (func 12)) + (export \"no_dce.f64.load\" (func 13))) + "; + 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_4(instance: &mut Instance) { + // TODO Review is explicit start needed? Start now called in runtime::Instance::new() + //instance.start(); +} + +// Line 78 +fn c22_l78_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c22_l78_action_invoke"); + let result = instance.call("no_dce.i32.load", &[Value::I32(65536 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c22_l78_assert_trap() { + let mut instance = create_module_4(); + let result = c22_l78_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 79 +fn c23_l79_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c23_l79_action_invoke"); + let result = instance.call("no_dce.i32.load16_s", &[Value::I32(65536 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c23_l79_assert_trap() { + let mut instance = create_module_4(); + let result = c23_l79_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 80 +fn c24_l80_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c24_l80_action_invoke"); + let result = instance.call("no_dce.i32.load16_u", &[Value::I32(65536 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c24_l80_assert_trap() { + let mut instance = create_module_4(); + let result = c24_l80_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 81 +fn c25_l81_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c25_l81_action_invoke"); + let result = instance.call("no_dce.i32.load8_s", &[Value::I32(65536 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c25_l81_assert_trap() { + let mut instance = create_module_4(); + let result = c25_l81_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 82 +fn c26_l82_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c26_l82_action_invoke"); + let result = instance.call("no_dce.i32.load8_u", &[Value::I32(65536 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c26_l82_assert_trap() { + let mut instance = create_module_4(); + let result = c26_l82_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 83 +fn c27_l83_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c27_l83_action_invoke"); + let result = instance.call("no_dce.i64.load", &[Value::I32(65536 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c27_l83_assert_trap() { + let mut instance = create_module_4(); + let result = c27_l83_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 84 +fn c28_l84_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c28_l84_action_invoke"); + let result = instance.call("no_dce.i64.load32_s", &[Value::I32(65536 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c28_l84_assert_trap() { + let mut instance = create_module_4(); + let result = c28_l84_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 85 +fn c29_l85_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c29_l85_action_invoke"); + let result = instance.call("no_dce.i64.load32_u", &[Value::I32(65536 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c29_l85_assert_trap() { + let mut instance = create_module_4(); + let result = c29_l85_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 86 +fn c30_l86_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c30_l86_action_invoke"); + let result = instance.call("no_dce.i64.load16_s", &[Value::I32(65536 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c30_l86_assert_trap() { + let mut instance = create_module_4(); + let result = c30_l86_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 87 +fn c31_l87_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c31_l87_action_invoke"); + let result = instance.call("no_dce.i64.load16_u", &[Value::I32(65536 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c31_l87_assert_trap() { + let mut instance = create_module_4(); + let result = c31_l87_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 88 +fn c32_l88_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c32_l88_action_invoke"); + let result = instance.call("no_dce.i64.load8_s", &[Value::I32(65536 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c32_l88_assert_trap() { + let mut instance = create_module_4(); + let result = c32_l88_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 89 +fn c33_l89_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c33_l89_action_invoke"); + let result = instance.call("no_dce.i64.load8_u", &[Value::I32(65536 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c33_l89_assert_trap() { + let mut instance = create_module_4(); + let result = c33_l89_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 90 +fn c34_l90_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c34_l90_action_invoke"); + let result = instance.call("no_dce.f32.load", &[Value::I32(65536 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c34_l90_assert_trap() { + let mut instance = create_module_4(); + let result = c34_l90_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 91 +fn c35_l91_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c35_l91_action_invoke"); + let result = instance.call("no_dce.f64.load", &[Value::I32(65536 as i32)]); + + result.map(|_| ()) +} + +#[test] +fn c35_l91_assert_trap() { + let mut instance = create_module_4(); + let result = c35_l91_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +#[test] +fn test_module_4() { + let mut instance = create_module_4(); + // We group the calls together + start_module_4(&mut instance); +} diff --git a/lib/runtime/tests/spectests/typecheck.rs b/lib/runtime/tests/spectests/typecheck.rs new file mode 100644 index 000000000..bcdde6d0b --- /dev/null +++ b/lib/runtime/tests/spectests/typecheck.rs @@ -0,0 +1,1563 @@ +// 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/typecheck.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 4 +#[test] +fn c0_l4_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 6, 1, 4, 0, 69, 26, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 10 +#[test] +fn c1_l10_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 11, 1, 9, 0, 65, 0, 2, 64, 69, 26, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 17 +#[test] +fn c2_l17_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 11, 1, 9, 0, 65, 0, 3, 64, 69, 26, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 24 +#[test] +fn c3_l24_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 65, 0, 65, 0, 4, 64, 69, 26, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 31 +#[test] +fn c4_l31_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 65, 0, 65, 0, 4, 127, 65, 0, 5, 69, 11, 26, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 39 +#[test] +fn c5_l39_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 6, 1, 4, 0, 106, 26, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 45 +#[test] +fn c6_l45_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 8, 1, 6, 0, 65, 0, 106, 26, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 51 +#[test] +fn c7_l51_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 65, 0, 65, 0, 2, 64, 106, 26, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 58 +#[test] +fn c8_l58_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 65, 0, 2, 64, 65, 0, 106, 26, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 65 +#[test] +fn c9_l65_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 65, 0, 65, 0, 3, 64, 106, 26, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 72 +#[test] +fn c10_l72_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 65, 0, 3, 64, 65, 0, 106, 26, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 79 +#[test] +fn c11_l79_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 15, 1, 13, 0, 65, 0, 65, 0, 65, 0, 106, 4, 64, 26, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 86 +#[test] +fn c12_l86_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 65, 0, 65, 0, 65, 0, 4, 64, 106, 5, 26, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 93 +#[test] +fn c13_l93_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 21, 1, 19, 0, 65, 0, 65, 0, 65, 0, 4, 127, 65, 0, 5, 106, 65, 0, 11, 26, 26, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 101 +#[test] +fn c14_l101_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 65, 0, 65, 0, 4, 127, 65, 0, 5, 106, 11, 26, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 110 +#[test] +fn c15_l110_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 4, 64, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 116 +#[test] +fn c16_l116_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 2, 64, 4, 64, 11, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 123 +#[test] +fn c17_l123_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 3, 64, 4, 64, 11, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 130 +#[test] +fn c18_l130_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 14, 1, 12, 0, 65, 0, 65, 0, 4, 64, 4, 64, 11, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 137 +#[test] +fn c19_l137_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 20, 1, 18, 0, 65, 0, 65, 0, 4, 127, 65, 0, 5, 4, 64, 11, 65, 0, 11, 26, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 146 +#[test] +fn c20_l146_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 127, 12, 0, 11, 69, 26, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 153 +#[test] +fn c21_l153_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 65, 0, 2, 127, 12, 0, 11, 69, 26, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 161 +#[test] +fn c22_l161_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 64, 65, 0, 65, 0, 4, 127, 12, 0, 11, 11, 69, 26, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 171 +#[test] +fn c23_l171_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 21, 1, 19, 0, 2, 64, 65, 0, 65, 0, 4, 127, 65, 0, 5, 12, 0, 11, 11, 69, 26, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 182 +#[test] +fn c24_l182_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 5, 1, 3, 0, 15, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 188 +#[test] +fn c25_l188_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 10, 1, 8, 0, 65, 0, 2, 64, 15, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 195 +#[test] +fn c26_l195_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 10, 1, 8, 0, 65, 0, 3, 64, 15, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 202 +#[test] +fn c27_l202_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 65, 0, 4, 64, 15, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 209 +#[test] +fn c28_l209_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 65, 0, 65, 0, 4, 127, 65, 0, 5, 15, 11, 26, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 219 +#[test] +fn c29_l219_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 67, 0, 0, 0, 0, 4, 64, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 222 +#[test] +fn c30_l222_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 64, 67, 0, 0, 0, 0, 13, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 226 +#[test] +fn c31_l226_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 64, 67, 0, 0, 0, 0, 14, 0, 0, 11, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 230 +#[test] +fn c32_l230_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 8, 2, 96, 1, 127, 0, 96, 0, 0, 3, 3, 2, 0, 1, 10, 14, 2, 2, 0, 11, 9, 0, 67, 0, 0, 0, 0, 16, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 232 +#[test] +fn c33_l232_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 8, 2, 96, 1, 127, 0, 96, 0, 0, 3, 3, 2, 0, 1, 4, 4, 1, 112, 0, 0, 10, 17, 2, 2, 0, 11, 12, 0, 65, 0, 67, 0, 0, 0, 0, 17, 0, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 242 +#[test] +fn c34_l242_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 3, 2, 0, 0, 4, 4, 1, 112, 0, 0, 10, 15, 2, 2, 0, 11, 10, 0, 67, 0, 0, 0, 0, 17, 0, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 250 +#[test] +fn c35_l250_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 10, 1, 8, 0, 67, 0, 0, 0, 0, 15, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 253 +#[test] +fn c36_l253_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 1, 1, 127, 67, 0, 0, 0, 0, 33, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 256 +#[test] +fn c37_l256_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, 0, 67, 0, 0, 0, 0, 40, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 257 +#[test] +fn c38_l257_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, 0, 67, 0, 0, 0, 0, 44, 0, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 258 +#[test] +fn c39_l258_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, 0, 67, 0, 0, 0, 0, 45, 0, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 259 +#[test] +fn c40_l259_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, 0, 67, 0, 0, 0, 0, 46, 1, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 260 +#[test] +fn c41_l260_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, 0, 67, 0, 0, 0, 0, 47, 1, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 261 +#[test] +fn c42_l261_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, 0, 67, 0, 0, 0, 0, 41, 3, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 262 +#[test] +fn c43_l262_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, 0, 67, 0, 0, 0, 0, 48, 0, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 263 +#[test] +fn c44_l263_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, 0, 67, 0, 0, 0, 0, 49, 0, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 264 +#[test] +fn c45_l264_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, 0, 67, 0, 0, 0, 0, 50, 1, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 265 +#[test] +fn c46_l265_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, 0, 67, 0, 0, 0, 0, 51, 1, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 266 +#[test] +fn c47_l266_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, 0, 67, 0, 0, 0, 0, 52, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 267 +#[test] +fn c48_l267_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, 0, 67, 0, 0, 0, 0, 53, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 268 +#[test] +fn c49_l268_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, 0, 67, 0, 0, 0, 0, 42, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 269 +#[test] +fn c50_l269_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 12, 1, 10, 0, 67, 0, 0, 0, 0, 43, 3, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 272 +#[test] +fn c51_l272_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 14, 1, 12, 0, 67, 0, 0, 0, 0, 65, 0, 54, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 273 +#[test] +fn c52_l273_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 14, 1, 12, 0, 67, 0, 0, 0, 0, 65, 0, 58, 0, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 274 +#[test] +fn c53_l274_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 14, 1, 12, 0, 67, 0, 0, 0, 0, 65, 0, 59, 1, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 275 +#[test] +fn c54_l275_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 14, 1, 12, 0, 67, 0, 0, 0, 0, 65, 0, 55, 3, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 276 +#[test] +fn c55_l276_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 14, 1, 12, 0, 67, 0, 0, 0, 0, 66, 0, 60, 0, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 277 +#[test] +fn c56_l277_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 14, 1, 12, 0, 67, 0, 0, 0, 0, 66, 0, 61, 1, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 278 +#[test] +fn c57_l278_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 14, 1, 12, 0, 67, 0, 0, 0, 0, 66, 0, 62, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 279 +#[test] +fn c58_l279_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 17, 1, 15, 0, 67, 0, 0, 0, 0, 67, 0, 0, 0, 0, 56, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 280 +#[test] +fn c59_l280_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 21, 1, 19, 0, 67, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 57, 3, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 283 +#[test] +fn c60_l283_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 14, 1, 12, 0, 65, 0, 67, 0, 0, 0, 0, 54, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 284 +#[test] +fn c61_l284_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 14, 1, 12, 0, 65, 0, 67, 0, 0, 0, 0, 58, 0, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 285 +#[test] +fn c62_l285_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 14, 1, 12, 0, 65, 0, 67, 0, 0, 0, 0, 59, 1, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 286 +#[test] +fn c63_l286_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 14, 1, 12, 0, 65, 0, 67, 0, 0, 0, 0, 55, 3, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 287 +#[test] +fn c64_l287_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 18, 1, 16, 0, 65, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 60, 0, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 288 +#[test] +fn c65_l288_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 18, 1, 16, 0, 65, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 61, 1, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 289 +#[test] +fn c66_l289_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 18, 1, 16, 0, 65, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 62, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 290 +#[test] +fn c67_l290_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 11, 1, 9, 0, 65, 0, 65, 0, 56, 2, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 291 +#[test] +fn c68_l291_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 11, 1, 9, 0, 65, 0, 66, 0, 57, 3, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 294 +#[test] +fn c69_l294_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 106, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 295 +#[test] +fn c70_l295_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 113, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 296 +#[test] +fn c71_l296_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 109, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 297 +#[test] +fn c72_l297_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 110, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 298 +#[test] +fn c73_l298_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 108, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 299 +#[test] +fn c74_l299_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 114, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 300 +#[test] +fn c75_l300_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 111, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 301 +#[test] +fn c76_l301_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 112, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 302 +#[test] +fn c77_l302_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 119, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 303 +#[test] +fn c78_l303_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 120, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 304 +#[test] +fn c79_l304_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 116, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 305 +#[test] +fn c80_l305_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 117, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 306 +#[test] +fn c81_l306_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 118, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 307 +#[test] +fn c82_l307_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 107, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 308 +#[test] +fn c83_l308_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 115, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 309 +#[test] +fn c84_l309_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 124, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 310 +#[test] +fn c85_l310_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 131, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 311 +#[test] +fn c86_l311_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 127, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 312 +#[test] +fn c87_l312_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 128, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 313 +#[test] +fn c88_l313_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 126, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 314 +#[test] +fn c89_l314_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 132, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 315 +#[test] +fn c90_l315_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 129, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 316 +#[test] +fn c91_l316_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 130, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 317 +#[test] +fn c92_l317_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 137, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 318 +#[test] +fn c93_l318_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 138, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 319 +#[test] +fn c94_l319_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 134, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 320 +#[test] +fn c95_l320_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 135, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 321 +#[test] +fn c96_l321_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 136, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 322 +#[test] +fn c97_l322_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 125, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 323 +#[test] +fn c98_l323_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 133, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 324 +#[test] +fn c99_l324_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 146, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 325 +#[test] +fn c100_l325_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 152, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 326 +#[test] +fn c101_l326_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 149, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 327 +#[test] +fn c102_l327_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 151, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 328 +#[test] +fn c103_l328_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 150, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 329 +#[test] +fn c104_l329_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 148, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 330 +#[test] +fn c105_l330_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 147, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 331 +#[test] +fn c106_l331_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 160, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 332 +#[test] +fn c107_l332_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 166, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 333 +#[test] +fn c108_l333_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 163, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 334 +#[test] +fn c109_l334_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 165, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 335 +#[test] +fn c110_l335_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 164, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 336 +#[test] +fn c111_l336_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 162, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 337 +#[test] +fn c112_l337_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 161, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 340 +#[test] +fn c113_l340_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 69, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 341 +#[test] +fn c114_l341_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 103, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 342 +#[test] +fn c115_l342_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 104, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 343 +#[test] +fn c116_l343_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 105, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 344 +#[test] +fn c117_l344_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 80, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 345 +#[test] +fn c118_l345_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 121, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 346 +#[test] +fn c119_l346_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 122, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 347 +#[test] +fn c120_l347_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 123, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 348 +#[test] +fn c121_l348_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 139, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 349 +#[test] +fn c122_l349_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 141, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 350 +#[test] +fn c123_l350_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 142, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 351 +#[test] +fn c124_l351_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 144, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 352 +#[test] +fn c125_l352_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 140, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 353 +#[test] +fn c126_l353_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 145, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 354 +#[test] +fn c127_l354_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 143, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 355 +#[test] +fn c128_l355_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 153, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 356 +#[test] +fn c129_l356_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 155, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 357 +#[test] +fn c130_l357_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 156, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 358 +#[test] +fn c131_l358_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 158, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 359 +#[test] +fn c132_l359_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 154, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 360 +#[test] +fn c133_l360_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 159, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 361 +#[test] +fn c134_l361_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 157, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 364 +#[test] +fn c135_l364_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 70, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 365 +#[test] +fn c136_l365_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 78, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 366 +#[test] +fn c137_l366_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 79, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 367 +#[test] +fn c138_l367_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 74, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 368 +#[test] +fn c139_l368_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 75, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 369 +#[test] +fn c140_l369_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 76, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 370 +#[test] +fn c141_l370_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 77, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 371 +#[test] +fn c142_l371_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 72, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 372 +#[test] +fn c143_l372_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 73, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 373 +#[test] +fn c144_l373_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 71, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 374 +#[test] +fn c145_l374_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 81, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 375 +#[test] +fn c146_l375_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 89, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 376 +#[test] +fn c147_l376_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 90, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 377 +#[test] +fn c148_l377_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 85, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 378 +#[test] +fn c149_l378_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 86, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 379 +#[test] +fn c150_l379_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 87, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 380 +#[test] +fn c151_l380_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 88, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 381 +#[test] +fn c152_l381_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 83, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 382 +#[test] +fn c153_l382_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 84, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 383 +#[test] +fn c154_l383_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 0, 67, 0, 0, 0, 0, 82, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 384 +#[test] +fn c155_l384_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 91, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 385 +#[test] +fn c156_l385_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 96, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 386 +#[test] +fn c157_l386_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 94, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 387 +#[test] +fn c158_l387_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 95, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 388 +#[test] +fn c159_l388_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 93, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 389 +#[test] +fn c160_l389_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 66, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 92, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 390 +#[test] +fn c161_l390_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 97, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 391 +#[test] +fn c162_l391_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 102, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 392 +#[test] +fn c163_l392_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 100, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 393 +#[test] +fn c164_l393_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 101, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 394 +#[test] +fn c165_l394_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 99, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 395 +#[test] +fn c166_l395_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 66, 0, 67, 0, 0, 0, 0, 98, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 398 +#[test] +fn c167_l398_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 10, 1, 8, 0, 67, 0, 0, 0, 0, 167, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 399 +#[test] +fn c168_l399_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 168, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 400 +#[test] +fn c169_l400_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 169, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 401 +#[test] +fn c170_l401_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 170, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 402 +#[test] +fn c171_l402_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 171, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 403 +#[test] +fn c172_l403_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 188, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 404 +#[test] +fn c173_l404_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 10, 1, 8, 0, 67, 0, 0, 0, 0, 172, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 405 +#[test] +fn c174_l405_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 10, 1, 8, 0, 67, 0, 0, 0, 0, 173, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 406 +#[test] +fn c175_l406_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 174, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 407 +#[test] +fn c176_l407_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 175, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 408 +#[test] +fn c177_l408_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 176, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 409 +#[test] +fn c178_l409_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 177, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 410 +#[test] +fn c179_l410_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 189, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 411 +#[test] +fn c180_l411_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 178, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 412 +#[test] +fn c181_l412_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 179, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 413 +#[test] +fn c182_l413_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 180, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 414 +#[test] +fn c183_l414_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 181, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 415 +#[test] +fn c184_l415_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 182, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 416 +#[test] +fn c185_l416_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 190, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 417 +#[test] +fn c186_l417_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 183, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 418 +#[test] +fn c187_l418_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 66, 0, 184, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 419 +#[test] +fn c188_l419_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 185, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 420 +#[test] +fn c189_l420_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 186, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 421 +#[test] +fn c190_l421_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 187, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 422 +#[test] +fn c191_l422_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 7, 1, 5, 0, 65, 0, 191, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 425 +#[test] +fn c192_l425_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 1, 10, 11, 1, 9, 0, 67, 0, 0, 0, 0, 64, 0, 11]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} diff --git a/lib/runtime/tests/spectests/types.rs b/lib/runtime/tests/spectests/types.rs new file mode 100644 index 000000000..5fc39739d --- /dev/null +++ b/lib/runtime/tests/spectests/types.rs @@ -0,0 +1,86 @@ +// 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/types.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 3 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func)) + (type (;1;) (func)) + (type (;2;) (func (param i32))) + (type (;3;) (func (param i32))) + (type (;4;) (func (result i32))) + (type (;5;) (func (param i32) (result i32))) + (type (;6;) (func (param i32) (result i32))) + (type (;7;) (func (param f32 f64))) + (type (;8;) (func (param f32 f64))) + (type (;9;) (func (param f32 f64))) + (type (;10;) (func (param f32 f64))) + (type (;11;) (func (param f32 f64))) + (type (;12;) (func (param f32 f64 i32 f64 i32 i32))) + (type (;13;) (func (param f32 f64 i32)))) + "; + 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 44 +#[test] +fn c1_l44_assert_malformed() { + let wasm_binary = [40, 116, 121, 112, 101, 32, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 48 +#[test] +fn c2_l48_assert_malformed() { + let wasm_binary = [40, 116, 121, 112, 101, 32, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 36, 120, 32, 105, 51, 50, 41, 41, 41]; + let compilation = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(compilation.is_err(), "WASM should not compile as is malformed"); +} + +// Line 53 +#[test] +fn c3_l53_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 0, 2, 127, 127]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +// Line 57 +#[test] +fn c4_l57_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 0, 2, 127, 127]; + let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new()); + assert!(module.is_err(), "WASM should not compile as is invalid"); +} + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); +} diff --git a/lib/runtime/tests/spectests/unwind.rs b/lib/runtime/tests/spectests/unwind.rs new file mode 100644 index 000000000..772bc7c32 --- /dev/null +++ b/lib/runtime/tests/spectests/unwind.rs @@ -0,0 +1,952 @@ +// 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/unwind.wast +#![allow( + warnings, + dead_code +)] +use wabt::wat2wasm; +use std::{f32, f64}; + +use wasmer_runtime::types::Value; +use wasmer_runtime::{Instance, Module}; +use wasmer_clif_backend::CraneliftCompiler; + +use crate::spectests::_common::{ + spectest_importobject, + NaNCheck, +}; + + +// Line 3 +fn create_module_1() -> Box { + let module_str = "(module + (type (;0;) (func)) + (type (;1;) (func (result i32))) + (func (;0;) (type 0) + i32.const 3 + i64.const 1 + unreachable) + (func (;1;) (type 0) + i32.const 3 + i64.const 1 + br 0 (;@0;)) + (func (;2;) (type 1) (result i32) + i32.const 3 + i64.const 1 + i32.const 9 + br 0 (;@0;)) + (func (;3;) (type 0) + i32.const 3 + i64.const 1 + i32.const 1 + br_if 0 (;@0;) + drop + drop) + (func (;4;) (type 1) (result i32) + i32.const 3 + i64.const 1 + i32.const 9 + i32.const 1 + br_if 0 (;@0;) + drop + drop) + (func (;5;) (type 0) + i32.const 3 + i64.const 1 + i32.const 0 + br_table 0 (;@0;)) + (func (;6;) (type 1) (result i32) + i32.const 3 + i64.const 1 + i32.const 9 + i32.const 0 + br_table 0 (;@0;)) + (func (;7;) (type 1) (result i32) + i32.const 3 + i64.const 1 + i32.const 9 + return) + (func (;8;) (type 0) + block ;; label = @1 + i32.const 3 + i64.const 1 + unreachable + end) + (func (;9;) (type 1) (result i32) + block ;; label = @1 + i32.const 3 + i64.const 1 + br 0 (;@1;) + end + i32.const 9) + (func (;10;) (type 1) (result i32) + block (result i32) ;; label = @1 + i32.const 3 + i64.const 1 + i32.const 9 + br 0 (;@1;) + end) + (func (;11;) (type 1) (result i32) + block ;; label = @1 + i32.const 3 + i64.const 1 + i32.const 1 + br_if 0 (;@1;) + drop + drop + end + i32.const 9) + (func (;12;) (type 1) (result i32) + block (result i32) ;; label = @1 + i32.const 3 + i64.const 1 + i32.const 9 + i32.const 1 + br_if 0 (;@1;) + drop + drop + end) + (func (;13;) (type 1) (result i32) + block ;; label = @1 + i32.const 3 + i64.const 1 + i32.const 0 + br_table 0 (;@1;) + end + i32.const 9) + (func (;14;) (type 1) (result i32) + block (result i32) ;; label = @1 + i32.const 3 + i64.const 1 + i32.const 9 + i32.const 0 + br_table 0 (;@1;) + end) + (func (;15;) (type 1) (result i32) + block (result i32) ;; label = @1 + i32.const 3 + i64.const 1 + i32.const 9 + return + end) + (func (;16;) (type 1) (result i32) + block (result i32) ;; label = @1 + i32.const 3 + block ;; label = @2 + i64.const 1 + unreachable + end + end) + (func (;17;) (type 1) (result i32) + block ;; label = @1 + i32.const 3 + block ;; label = @2 + i64.const 1 + br 1 (;@1;) + end + drop + end + i32.const 9) + (func (;18;) (type 1) (result i32) + block (result i32) ;; label = @1 + i32.const 3 + block ;; label = @2 + i64.const 1 + i32.const 9 + br 1 (;@1;) + end + end) + (func (;19;) (type 1) (result i32) + block ;; label = @1 + i32.const 3 + block ;; label = @2 + i64.const 1 + i32.const 1 + br_if 1 (;@1;) + drop + end + drop + end + i32.const 9) + (func (;20;) (type 1) (result i32) + block (result i32) ;; label = @1 + i32.const 3 + block ;; label = @2 + i64.const 1 + i32.const 9 + i32.const 1 + br_if 1 (;@1;) + drop + drop + end + end) + (func (;21;) (type 1) (result i32) + block ;; label = @1 + i32.const 3 + block ;; label = @2 + i64.const 1 + i32.const 1 + br_table 1 (;@1;) + end + drop + end + i32.const 9) + (func (;22;) (type 1) (result i32) + block (result i32) ;; label = @1 + i32.const 3 + block ;; label = @2 + i64.const 1 + i32.const 9 + i32.const 1 + br_table 1 (;@1;) + end + end) + (func (;23;) (type 1) (result i32) + block (result i32) ;; label = @1 + i32.const 3 + block ;; label = @2 + i64.const 1 + i32.const 9 + return + end + end) + (func (;24;) (type 1) (result i32) + f32.const 0x0p+0 (;=0;) + unreachable + i64.eqz) + (func (;25;) (type 1) (result i32) + block (result i32) ;; label = @1 + f32.const 0x0p+0 (;=0;) + i32.const 9 + br 0 (;@1;) + i64.eqz + end) + (func (;26;) (type 1) (result i32) + block (result i32) ;; label = @1 + i64.const 0 + i32.const 9 + i32.const 1 + br_if 0 (;@1;) + drop + i64.eqz + end) + (func (;27;) (type 1) (result i32) + block (result i32) ;; label = @1 + f32.const 0x0p+0 (;=0;) + i32.const 9 + i32.const 0 + br_table 0 (;@1;) 0 (;@1;) + i64.eqz + end) + (func (;28;) (type 1) (result i32) + f32.const 0x0p+0 (;=0;) + i32.const 9 + return + i64.eqz) + (func (;29;) (type 1) (result i32) + f32.const 0x0p+0 (;=0;) + f64.const 0x1p+0 (;=1;) + unreachable + i64.eq) + (func (;30;) (type 1) (result i32) + block (result i32) ;; label = @1 + f32.const 0x0p+0 (;=0;) + f64.const 0x1p+0 (;=1;) + i32.const 9 + br 0 (;@1;) + i64.eq + end) + (func (;31;) (type 1) (result i32) + block (result i32) ;; label = @1 + i64.const 0 + i64.const 1 + i32.const 9 + i32.const 1 + br_if 0 (;@1;) + drop + i64.eq + end) + (func (;32;) (type 1) (result i32) + block (result i32) ;; label = @1 + f32.const 0x0p+0 (;=0;) + f64.const 0x1p+0 (;=1;) + i32.const 9 + i32.const 0 + br_table 0 (;@1;) + i64.eq + end) + (func (;33;) (type 1) (result i32) + f32.const 0x0p+0 (;=0;) + f64.const 0x1p+0 (;=1;) + i32.const 9 + return + i64.eq) + (func (;34;) (type 1) (result i32) + f32.const 0x0p+0 (;=0;) + f64.const 0x1p+0 (;=1;) + i64.const 0 + unreachable + select) + (func (;35;) (type 1) (result i32) + block (result i32) ;; label = @1 + f32.const 0x0p+0 (;=0;) + f64.const 0x1p+0 (;=1;) + i64.const 0 + i32.const 9 + br 0 (;@1;) + select + end) + (func (;36;) (type 1) (result i32) + block (result i32) ;; label = @1 + i32.const 0 + i32.const 1 + i32.const 0 + i32.const 9 + i32.const 1 + br_if 0 (;@1;) + drop + select + end) + (func (;37;) (type 1) (result i32) + block (result i32) ;; label = @1 + f32.const 0x0p+0 (;=0;) + f64.const 0x1p+0 (;=1;) + i64.const 0 + i32.const 9 + i32.const 0 + br_table 0 (;@1;) + select + end) + (func (;38;) (type 1) (result i32) + f32.const 0x0p+0 (;=0;) + f64.const 0x1p+0 (;=1;) + i64.const 1 + i32.const 9 + return + select) + (func (;39;) (type 1) (result i32) + block (result i32) ;; label = @1 + f32.const 0x0p+0 (;=0;) + unreachable + end) + (func (;40;) (type 1) (result i32) + block (result i32) ;; label = @1 + f32.const 0x0p+0 (;=0;) + i32.const 9 + br 0 (;@1;) + end) + (func (;41;) (type 1) (result i32) + block (result i32) ;; label = @1 + i32.const 0 + i32.const 9 + i32.const 1 + br_if 0 (;@1;) + drop + end) + (func (;42;) (type 1) (result i32) + block (result i32) ;; label = @1 + f32.const 0x0p+0 (;=0;) + i32.const 9 + i32.const 0 + br_table 0 (;@1;) 0 (;@1;) + end) + (func (;43;) (type 1) (result i32) + block (result i32) ;; label = @1 + f32.const 0x0p+0 (;=0;) + i32.const 9 + return + end) + (func (;44;) (type 1) (result i32) + loop (result i32) ;; label = @1 + f32.const 0x0p+0 (;=0;) + unreachable + end) + (func (;45;) (type 1) (result i32) + block (result i32) ;; label = @1 + loop (result i32) ;; label = @2 + f32.const 0x0p+0 (;=0;) + i32.const 9 + br 1 (;@1;) + end + end) + (func (;46;) (type 1) (result i32) + block (result i32) ;; label = @1 + loop (result i32) ;; label = @2 + i32.const 0 + i32.const 9 + i32.const 1 + br_if 1 (;@1;) + drop + end + end) + (func (;47;) (type 1) (result i32) + block (result i32) ;; label = @1 + loop (result i32) ;; label = @2 + f32.const 0x0p+0 (;=0;) + i32.const 9 + i32.const 0 + br_table 1 (;@1;) 1 (;@1;) + end + end) + (func (;48;) (type 1) (result i32) + loop (result i32) ;; label = @1 + f32.const 0x0p+0 (;=0;) + i32.const 9 + return + end) + (export \"func-unwind-by-unreachable\" (func 0)) + (export \"func-unwind-by-br\" (func 1)) + (export \"func-unwind-by-br-value\" (func 2)) + (export \"func-unwind-by-br_if\" (func 3)) + (export \"func-unwind-by-br_if-value\" (func 4)) + (export \"func-unwind-by-br_table\" (func 5)) + (export \"func-unwind-by-br_table-value\" (func 6)) + (export \"func-unwind-by-return\" (func 7)) + (export \"block-unwind-by-unreachable\" (func 8)) + (export \"block-unwind-by-br\" (func 9)) + (export \"block-unwind-by-br-value\" (func 10)) + (export \"block-unwind-by-br_if\" (func 11)) + (export \"block-unwind-by-br_if-value\" (func 12)) + (export \"block-unwind-by-br_table\" (func 13)) + (export \"block-unwind-by-br_table-value\" (func 14)) + (export \"block-unwind-by-return\" (func 15)) + (export \"block-nested-unwind-by-unreachable\" (func 16)) + (export \"block-nested-unwind-by-br\" (func 17)) + (export \"block-nested-unwind-by-br-value\" (func 18)) + (export \"block-nested-unwind-by-br_if\" (func 19)) + (export \"block-nested-unwind-by-br_if-value\" (func 20)) + (export \"block-nested-unwind-by-br_table\" (func 21)) + (export \"block-nested-unwind-by-br_table-value\" (func 22)) + (export \"block-nested-unwind-by-return\" (func 23)) + (export \"unary-after-unreachable\" (func 24)) + (export \"unary-after-br\" (func 25)) + (export \"unary-after-br_if\" (func 26)) + (export \"unary-after-br_table\" (func 27)) + (export \"unary-after-return\" (func 28)) + (export \"binary-after-unreachable\" (func 29)) + (export \"binary-after-br\" (func 30)) + (export \"binary-after-br_if\" (func 31)) + (export \"binary-after-br_table\" (func 32)) + (export \"binary-after-return\" (func 33)) + (export \"select-after-unreachable\" (func 34)) + (export \"select-after-br\" (func 35)) + (export \"select-after-br_if\" (func 36)) + (export \"select-after-br_table\" (func 37)) + (export \"select-after-return\" (func 38)) + (export \"block-value-after-unreachable\" (func 39)) + (export \"block-value-after-br\" (func 40)) + (export \"block-value-after-br_if\" (func 41)) + (export \"block-value-after-br_table\" (func 42)) + (export \"block-value-after-return\" (func 43)) + (export \"loop-value-after-unreachable\" (func 44)) + (export \"loop-value-after-br\" (func 45)) + (export \"loop-value-after-br_if\" (func 46)) + (export \"loop-value-after-br_table\" (func 47)) + (export \"loop-value-after-return\" (func 48))) + "; + 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 212 +fn c1_l212_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c1_l212_action_invoke"); + let result = instance.call("func-unwind-by-unreachable", &[]); + + result.map(|_| ()) +} + +#[test] +fn c1_l212_assert_trap() { + let mut instance = create_module_1(); + let result = c1_l212_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 213 +fn c2_l213_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c2_l213_action_invoke"); + let result = instance.call("func-unwind-by-br", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 214 +fn c3_l214_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c3_l214_action_invoke"); + let result = instance.call("func-unwind-by-br-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 215 +fn c4_l215_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c4_l215_action_invoke"); + let result = instance.call("func-unwind-by-br_if", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 216 +fn c5_l216_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c5_l216_action_invoke"); + let result = instance.call("func-unwind-by-br_if-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 217 +fn c6_l217_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c6_l217_action_invoke"); + let result = instance.call("func-unwind-by-br_table", &[]); + assert_eq!(result, Ok(None)); + result.map(|_| ()) +} + +// Line 218 +fn c7_l218_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c7_l218_action_invoke"); + let result = instance.call("func-unwind-by-br_table-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 219 +fn c8_l219_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c8_l219_action_invoke"); + let result = instance.call("func-unwind-by-return", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 221 +fn c9_l221_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c9_l221_action_invoke"); + let result = instance.call("block-unwind-by-unreachable", &[]); + + result.map(|_| ()) +} + +#[test] +fn c9_l221_assert_trap() { + let mut instance = create_module_1(); + let result = c9_l221_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 222 +fn c10_l222_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c10_l222_action_invoke"); + let result = instance.call("block-unwind-by-br", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 223 +fn c11_l223_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c11_l223_action_invoke"); + let result = instance.call("block-unwind-by-br-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 224 +fn c12_l224_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c12_l224_action_invoke"); + let result = instance.call("block-unwind-by-br_if", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 225 +fn c13_l225_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c13_l225_action_invoke"); + let result = instance.call("block-unwind-by-br_if-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 226 +fn c14_l226_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c14_l226_action_invoke"); + let result = instance.call("block-unwind-by-br_table", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 227 +fn c15_l227_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c15_l227_action_invoke"); + let result = instance.call("block-unwind-by-br_table-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 228 +fn c16_l228_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c16_l228_action_invoke"); + let result = instance.call("block-unwind-by-return", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 230 +fn c17_l230_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c17_l230_action_invoke"); + let result = instance.call("block-nested-unwind-by-unreachable", &[]); + + result.map(|_| ()) +} + +#[test] +fn c17_l230_assert_trap() { + let mut instance = create_module_1(); + let result = c17_l230_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 231 +fn c18_l231_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c18_l231_action_invoke"); + let result = instance.call("block-nested-unwind-by-br", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 232 +fn c19_l232_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c19_l232_action_invoke"); + let result = instance.call("block-nested-unwind-by-br-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 233 +fn c20_l233_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c20_l233_action_invoke"); + let result = instance.call("block-nested-unwind-by-br_if", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 234 +fn c21_l234_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c21_l234_action_invoke"); + let result = instance.call("block-nested-unwind-by-br_if-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 235 +fn c22_l235_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c22_l235_action_invoke"); + let result = instance.call("block-nested-unwind-by-br_table", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 236 +fn c23_l236_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c23_l236_action_invoke"); + let result = instance.call("block-nested-unwind-by-br_table-value", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 237 +fn c24_l237_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c24_l237_action_invoke"); + let result = instance.call("block-nested-unwind-by-return", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 239 +fn c25_l239_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c25_l239_action_invoke"); + let result = instance.call("unary-after-unreachable", &[]); + + result.map(|_| ()) +} + +#[test] +fn c25_l239_assert_trap() { + let mut instance = create_module_1(); + let result = c25_l239_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 240 +fn c26_l240_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c26_l240_action_invoke"); + let result = instance.call("unary-after-br", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 241 +fn c27_l241_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c27_l241_action_invoke"); + let result = instance.call("unary-after-br_if", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 242 +fn c28_l242_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c28_l242_action_invoke"); + let result = instance.call("unary-after-br_table", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 243 +fn c29_l243_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c29_l243_action_invoke"); + let result = instance.call("unary-after-return", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 245 +fn c30_l245_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c30_l245_action_invoke"); + let result = instance.call("binary-after-unreachable", &[]); + + result.map(|_| ()) +} + +#[test] +fn c30_l245_assert_trap() { + let mut instance = create_module_1(); + let result = c30_l245_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 246 +fn c31_l246_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c31_l246_action_invoke"); + let result = instance.call("binary-after-br", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 247 +fn c32_l247_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c32_l247_action_invoke"); + let result = instance.call("binary-after-br_if", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 248 +fn c33_l248_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c33_l248_action_invoke"); + let result = instance.call("binary-after-br_table", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 249 +fn c34_l249_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c34_l249_action_invoke"); + let result = instance.call("binary-after-return", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 251 +fn c35_l251_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c35_l251_action_invoke"); + let result = instance.call("select-after-unreachable", &[]); + + result.map(|_| ()) +} + +#[test] +fn c35_l251_assert_trap() { + let mut instance = create_module_1(); + let result = c35_l251_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 252 +fn c36_l252_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c36_l252_action_invoke"); + let result = instance.call("select-after-br", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 253 +fn c37_l253_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c37_l253_action_invoke"); + let result = instance.call("select-after-br_if", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 254 +fn c38_l254_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c38_l254_action_invoke"); + let result = instance.call("select-after-br_table", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 255 +fn c39_l255_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c39_l255_action_invoke"); + let result = instance.call("select-after-return", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 257 +fn c40_l257_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c40_l257_action_invoke"); + let result = instance.call("block-value-after-unreachable", &[]); + + result.map(|_| ()) +} + +#[test] +fn c40_l257_assert_trap() { + let mut instance = create_module_1(); + let result = c40_l257_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 258 +fn c41_l258_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c41_l258_action_invoke"); + let result = instance.call("block-value-after-br", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 259 +fn c42_l259_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c42_l259_action_invoke"); + let result = instance.call("block-value-after-br_if", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 260 +fn c43_l260_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c43_l260_action_invoke"); + let result = instance.call("block-value-after-br_table", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 261 +fn c44_l261_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c44_l261_action_invoke"); + let result = instance.call("block-value-after-return", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 263 +fn c45_l263_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c45_l263_action_invoke"); + let result = instance.call("loop-value-after-unreachable", &[]); + + result.map(|_| ()) +} + +#[test] +fn c45_l263_assert_trap() { + let mut instance = create_module_1(); + let result = c45_l263_action_invoke(&mut*instance); + assert!(result.is_err()); +} + +// Line 264 +fn c46_l264_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c46_l264_action_invoke"); + let result = instance.call("loop-value-after-br", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 265 +fn c47_l265_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c47_l265_action_invoke"); + let result = instance.call("loop-value-after-br_if", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 266 +fn c48_l266_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c48_l266_action_invoke"); + let result = instance.call("loop-value-after-br_table", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +// Line 267 +fn c49_l267_action_invoke(instance: &mut Instance) -> Result<(), String> { + println!("Executing function {}", "c49_l267_action_invoke"); + let result = instance.call("loop-value-after-return", &[]); + assert_eq!(result, Ok(Some(Value::I32(9 as i32)))); + result.map(|_| ()) +} + +#[test] +fn test_module_1() { + let mut instance = create_module_1(); + // We group the calls together + start_module_1(&mut instance); + c2_l213_action_invoke(&mut instance); + c3_l214_action_invoke(&mut instance); + c4_l215_action_invoke(&mut instance); + c5_l216_action_invoke(&mut instance); + c6_l217_action_invoke(&mut instance); + c7_l218_action_invoke(&mut instance); + c8_l219_action_invoke(&mut instance); + c10_l222_action_invoke(&mut instance); + c11_l223_action_invoke(&mut instance); + c12_l224_action_invoke(&mut instance); + c13_l225_action_invoke(&mut instance); + c14_l226_action_invoke(&mut instance); + c15_l227_action_invoke(&mut instance); + c16_l228_action_invoke(&mut instance); + c18_l231_action_invoke(&mut instance); + c19_l232_action_invoke(&mut instance); + c20_l233_action_invoke(&mut instance); + c21_l234_action_invoke(&mut instance); + c22_l235_action_invoke(&mut instance); + c23_l236_action_invoke(&mut instance); + c24_l237_action_invoke(&mut instance); + c26_l240_action_invoke(&mut instance); + c27_l241_action_invoke(&mut instance); + c28_l242_action_invoke(&mut instance); + c29_l243_action_invoke(&mut instance); + c31_l246_action_invoke(&mut instance); + c32_l247_action_invoke(&mut instance); + c33_l248_action_invoke(&mut instance); + c34_l249_action_invoke(&mut instance); + c36_l252_action_invoke(&mut instance); + c37_l253_action_invoke(&mut instance); + c38_l254_action_invoke(&mut instance); + c39_l255_action_invoke(&mut instance); + c41_l258_action_invoke(&mut instance); + c42_l259_action_invoke(&mut instance); + c43_l260_action_invoke(&mut instance); + c44_l261_action_invoke(&mut instance); + c46_l264_action_invoke(&mut instance); + c47_l265_action_invoke(&mut instance); + c48_l266_action_invoke(&mut instance); + c49_l267_action_invoke(&mut instance); +}